Changeset 4748 for trunk/src

Timestamp:

Dec 3, 2000, 11:19:43 PM (25 years ago)

Author:

sandervl

Message:

CW: Ported Wine MCI code

Location:

trunk/src/winmm

Files:

• driver.cpp (modified) (18 diffs)
• initterm.cpp (modified) (7 diffs)
• mci.cpp (modified) (13 diffs)
• mcimm.h (added)
• winmm_En.orc (added)
• winmm_Es.orc (added)
• winmm_Fr.orc (added)
• winmm_Nl.orc (added)
• winmm_Pt.orc (added)
• winmm_Ru.orc (added)
• winmmrsrc.orc (modified) (2 diffs)

trunk/src/winmm/driver.cpp

@@ -1 @@
-/* $Id: driver.cpp,v 1.6 2000-11-19 12:46:50 sandervl Exp $ */
+/* $Id: driver.cpp,v 1.7 2000-12-03 22:18:17 sandervl Exp $ */
 
 /*
  * Driver multimedia apis
  *
+ * Copyright 1994 Martin Ayotte
+ * Copyright 1998 Marcus Meissner
  * Copyright 1998 Patrick Haller
- *
+ * Copyright 1998/1999 Eric Pouech
+ * Copyright 2000 Chris Wohlgemuth
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -17 +20 @@
 
 #include <os2win.h>
-#include <mmsystem.h>
 #include <odinwrap.h>
 #include <string.h>
@@ -23 +25 @@
 #include <unicode.h>
 
-#include "winmm.h"
 #include "os2timer.h"
 
 #define DBG_LOCALLOG    DBG_driver
 #include "dbglocal.h"
+
+
+/* Who said goofy boy ? */
+#define WINE_DI_MAGIC   0x900F1B01
+
+typedef struct tagWINE_DRIVER
+{
+    DWORD                       dwMagic;
+    char                        szAliasName[128];
+    /* as usual LPWINE_DRIVER == hDriver32 */
+    HDRVR16                     hDriver16;
+    union {
+       struct {
+          HMODULE16             hModule;
+          DRIVERPROC16          lpDrvProc;
+       } d16;
+       struct {
+          HMODULE               hModule;
+          DRIVERPROC            lpDrvProc;
+       } d32;
+    } d;
+    DWORD                       dwDriverID;
+    DWORD                       dwFlags;
+    struct tagWINE_DRIVER*      lpPrevItem;
+    struct tagWINE_DRIVER*      lpNextItem;
+} WINE_DRIVER, *LPWINE_DRIVER;
+
+static LPWINE_DRIVER    DRIVER_RegisterDriver32(LPCSTR, HMODULE,   DRIVERPROC,   LPARAM, BOOL);
+
+static LPWINE_DRIVER    lpDrvItemList = NULL;
+
+/* TODO list :
+ *      WINE remark: - LoadModule count and clean up is not handled correctly (it's not a 
+ *        problem as long as FreeLibrary is not working correctly)
+ *      - shoudln't the allocations be done on a per process basis ?
+ */
+
+static HDRVR DRIVER_OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam) ;
+static  LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr);
+static BOOL DRIVER_CloseDriver(LPWINE_DRIVER lpDrv, DWORD lParam1, DWORD lParam2);
 
 ODINDEBUGCHANNEL(WINMM-DRIVER)
@@ -39 +80 @@
  *             LONG  lParam2
  * Variables :
- * Result    : API returncode
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   : API returncode
+ * Remark    :
+ * @status   : Completely
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @author    : Chris Wohlgemuth [Sun, 2000/11/19]
  *****************************************************************************/
 
@@ -52 +94 @@
               LONG, lParam2)
 {
-  dprintf(("WINMM: SendDriverMessage not implemented.\n"));
-  return 0; /* unsuccessful return */
+    LPWINE_DRIVER       lpDrv;
+    LRESULT             retval = 0;
+
+    dprintf(("Entering SendDriverMessage (%04x, %04X, %08lX, %08lX)\n", hdrvr, msg, lParam1, lParam2));
+    
+    lpDrv = DRIVER_FindFromHDrvr(hdrvr);
+
+    if (lpDrv != NULL) {
+        if (lpDrv->dwFlags & WINE_GDF_16BIT) {
+#if 0
+      /*We don't use 16 bit */
+      mapRet = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2);
+      if (mapRet >= 0) {
+                TRACE("Before CallDriverProc proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n", 
+                      lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID, lpDrv->hDriver16, msg, lParam1, lParam2);                
+                retval = DRIVER_CallTo16_long_lwwll((FARPROC16)lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID, 
+                                            lpDrv->hDriver16, msg, lParam1, lParam2);
+                if (mapRet >= 1) {
+          DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
+                }
+      } else {
+                retval = 0;
+      }
+#endif
+        } else {
+
+#if 0
+      dprintf(("Before func32 call proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n", 
+               lpDrv->d.d32.lpDrvProc, lpDrv->dwDriverID, hdrvr, msg, lParam1, lParam2));                 
+#endif
+
+      retval = lpDrv->d.d32.lpDrvProc(lpDrv->dwDriverID, hdrvr, msg, lParam1, lParam2);
+        }
+    } else {
+      dprintf(("Bad driver handle %u\n", hdrvr));
+    }
+
+    dprintf(("(SendDriverMessage) Driver proc returned retval = %ld (0x%lx)\n", retval, retval));
+    
+    return retval;
 }
 
@@ -65 +145 @@
  *             LONG    lParam
  * Variables :
- * Result    : API returncode
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   : API returncode
+ * Remark    :
+ * @status   : Stub
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -77 +157 @@
               LONG, lParam)
 {
-  dprintf(("WINMM: OpenDriver %x %x %x not implemented, lpDriverName, lpSectionName"));
+  dprintf(("WINMM: OpenDriver not implemented.\n"));
   return 0; /* unsuccessful return */
 }
@@ -90 +170 @@
  *             LONG    lParam
  * Variables :
- * Result    : API returncode
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   : API returncode
+ * Remark    :
+ * @status   : Partially tested
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -102 +182 @@
               LONG, lParam)
 {
-  dprintf(("WINMM: OpenDriverA %s %s %x not implemented, lpDriverName, lpSectionName"));
-  return 0; /* unsuccessful return */
+  return DRIVER_OpenDriverA(lpDriverName, lpSectionName,  lParam); 
+  //  return 0; /* unsuccessful return */
 }
 
@@ -114 +194 @@
  *             LONG  lParam2
  * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   :
+ * Remark    :
+ * @status   : Partially tested
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -126 +206 @@
               LONG, lParam2)
 {
-  dprintf(("WINMM: CloseDriver not implemented.\n"));
-  return 0; /* unsuccessful return */
+  return DRIVER_CloseDriver(DRIVER_FindFromHDrvr(hDrvr), lParam1, lParam2);//return 0; /* unsuccessful return */
 }
 
@@ -140 +219 @@
  *             LONG  lParam2
  * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   :
+ * Remark    :
+ * @status   : Partially
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @author    : Chris Wohlgemuth [Sun, 2000/11/19]
  *****************************************************************************/
 
@@ -154 +234 @@
               LONG, lParam2)
 {
-  dprintf(("WINMM: DefDriverProc not implemented.\n"));
-  return 0; /* unsuccessful return */
+  switch (msg) {
+  case DRV_LOAD:
+  case DRV_FREE:
+  case DRV_ENABLE:
+  case DRV_DISABLE:
+    // return 1;
+  case DRV_INSTALL:
+  case DRV_REMOVE:
+    //  return DRV_SUCCESS;
+  default:
+    return 0; /* unsuccessful return */
+  }
+
 }
 
@@ -168 +259 @@
  *             DWORD dwParam2
  * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   :
+ * Remark    :
+ * @status   : Stub
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -194 +285 @@
  * Parameters: HDRVR hDriver
  * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @return   :
+ * Remark    :
+ * @status   : Stub
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -216 +307 @@
  *             LONG  lParam2
  * Variables :
- * Result    : API returncode
+ * @return   : API returncode
  * Remark    : Ehm, what's the difference to SendDriverMessage() ?
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @status   : Stub
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
  *****************************************************************************/
 
@@ -239 +330 @@
  * Parameters: HDRVR hDriver
  * Variables :
- * Result    :
+ * @return   :
  * Remark    : What's the difference to DrvGetModuleHandle() ?
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @status   : Completely
+ *
+ * @author    : Patrick Haller [Tue, 1998/05/05 10:44]
+ * @author    : Chris Wohlgemuth [Sun, 2000/11/19]
  *****************************************************************************/
 
@@ -249 +341 @@
               HDRVR, hDriver)
 {
-  dprintf(("WINMM: GetDriverModuleHandle not implemented.\n"));
-  return 0; /* unsuccessful return */
-}
-
+  LPWINE_DRIVER         lpDrv;
+  HMODULE               hModule = 0;
+  
+#if 0
+  dprintf(("(%04x);\n", hDriver));
+#endif
+
+  lpDrv = DRIVER_FindFromHDrvr(hDriver);
+  if (lpDrv != NULL && !(lpDrv->dwFlags & WINE_GDF_16BIT)) {
+        hModule = lpDrv->d.d32.hModule;
+  
+}
+#if 0
+  dprintf(("=> %d\n", hModule));
+#endif
+  return hModule; //return 0; /* unsuccessful return */
+}
+
+
+
+/**************************************************************************
+ *                              GetDriverFlags          [WINMM.13]
+ * Parameters: HDRVR hDrvr
+ * Variables :
+ * @return   :  0x00000000 if hDrvr is an invalid handle
+ *              0x80000000 if hDrvr is a valid 32 bit driver
+ * Remark    :
+ * @status   : Completely
+ *
+ * @author    : Chris Wohlgemuth [Sun, 2000/11/19] (ported from WINE)
+ */
+ODINFUNCTION1(DWORD, GetDriverFlags,
+              HDRVR, hDrvr)
+{
+    LPWINE_DRIVER       lpDrv;
+    DWORD               ret = 0;
+
+    //TRACE("(%04x)\n", hDrvr);
+
+    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
+      ret = lpDrv->dwFlags;
+    }
+    return ret;
+}
+
+
+/**************************************************************************/
+/*              Implementation                                            */
+/**************************************************************************/
+
+/**************************************************************************
+ *                      DRIVER_GetNumberOfModuleRefs            [internal]
+ *
+ * Returns the number of open drivers which share the same module.
+ */
+static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
+{
+    LPWINE_DRIVER       lpDrv;
+    WORD                count = 0;
+    
+    for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
+        if (lpDrv->dwFlags & WINE_GDF_16BIT) {
+            if (lpDrv->d.d16.hModule == lpNewDrv->d.d16.hModule) {
+                count++;
+            }
+        } else {
+            if (lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
+                count++;
+            }
+        }
+    }
+    return count;
+}
+
+
+/**************************************************************************
+ *                              DRIVER_FindFromHDrvr            [internal]
+ * 
+ * From a hDrvr (being 16 or 32 bits), returns the WINE internal structure.
+ */
+static  LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
+{    
+  if (!IsBadWritePtr((void*)hDrvr, sizeof(WINE_DRIVER)) && 
+      ((LPWINE_DRIVER)hDrvr)->dwMagic == WINE_DI_MAGIC) {
+        return (LPWINE_DRIVER)hDrvr;
+  }
+  return 0;
+}
+
+/**************************************************************************
+ *                              DRIVER_RemoveFromList           [internal]
+ *
+ * Generates all the logic to handle driver closure / deletion
+ * Removes a driver struct to the list of open drivers.
+ *
+ */
+static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
+{
+    lpDrv->dwDriverID = 0;
+    if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
+      SendDriverMessage((HDRVR)lpDrv, DRV_DISABLE, 0L, 0L);
+      SendDriverMessage((HDRVR)lpDrv, DRV_FREE,    0L, 0L);
+    }
+    
+    if (lpDrv->lpPrevItem)
+        lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
+    else
+        lpDrvItemList = lpDrv->lpNextItem;
+    if (lpDrv->lpNextItem)
+        lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
+
+    return TRUE;
+}
+
+/**************************************************************************
+ *                              DRIVER_AddToList                [internal]
+ *
+ * Adds a driver struct to the list of open drivers.
+ * Generates all the logic to handle driver creation / open.
+ *
+ */
+static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam, BOOL bCallFrom32)
+{
+  lpNewDrv->dwMagic = WINE_DI_MAGIC;
+  /* First driver to be loaded for this module, need to load correctly the module */
+
+  if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
+        if (SendDriverMessage((HDRVR)lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
+      dprintf(("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv));
+      return FALSE;
+        }
+        if (SendDriverMessage((HDRVR)lpNewDrv, DRV_ENABLE, 0L, 0L) != DRV_SUCCESS) {
+      dprintf(("DRV_ENABLE failed on driver 0x%08lx\n", (DWORD)lpNewDrv));
+      return FALSE;
+        }
+  }
+  
+  lpNewDrv->lpNextItem = NULL;
+  if (lpDrvItemList == NULL) {
+        lpDrvItemList = lpNewDrv;
+        lpNewDrv->lpPrevItem = NULL;
+  } else {
+        LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
+        while (lpDrv->lpNextItem != NULL)
+      lpDrv = lpDrv->lpNextItem;
+        
+        lpDrv->lpNextItem = lpNewDrv;
+        lpNewDrv->lpPrevItem = lpDrv;
+  }
+  /* Now just open a new instance of a driver on this module */
+  
+  lpNewDrv->dwDriverID = SendDriverMessage((HDRVR)lpNewDrv, DRV_OPEN, 0L, lParam);
+  
+  if (lpNewDrv->dwDriverID == 0) {
+        dprintf(("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv));
+        DRIVER_RemoveFromList(lpNewDrv);
+        return FALSE;
+  }
+    
+  return TRUE;
+}
+
+/**************************************************************************
+ *                              DRIVER_RegisterDriver32         [internal]
+ *
+ * Creates all the WINE internal representations for a 32 bit driver.
+ * The driver is also open by sending the correct messages.
+ *
+ */
+static LPWINE_DRIVER DRIVER_RegisterDriver32(LPCSTR lpName, HMODULE hModule, DRIVERPROC lpProc, 
+                                      LPARAM lParam, BOOL bCallFrom32)
+{
+  LPWINE_DRIVER lpDrv;
+  
+  lpDrv = (LPWINE_DRIVER)HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
+  if (lpDrv != NULL) {
+        lpDrv->dwFlags          = WINE_GDF_EXIST;
+        lpDrv->dwDriverID       = 0;
+    lpDrv->hDriver16        = 0;  /* We don't support 16 bit */
+        lstrcpynA(lpDrv->szAliasName, lpName, sizeof(lpDrv->szAliasName));
+        lpDrv->d.d32.hModule    = hModule;
+        lpDrv->d.d32.lpDrvProc  = lpProc;
+
+        if (!DRIVER_AddToList(lpDrv, lParam, bCallFrom32)) {
+      HeapFree(GetProcessHeap(), 0, lpDrv);
+      lpDrv = NULL;
+        }
+
+  }
+  return lpDrv;
+}
+
+/**************************************************************************
+ *                              DRIVER_TryOpenDriver32          [internal]
+ *
+ * Tries to load a 32 bit driver whose DLL's (module) name is lpFileName.
+ *
+ */
+static  HDRVR   DRIVER_TryOpenDriver32(LPCSTR lpFileName, LPARAM lParam, BOOL bCallFrom32)
+{
+    LPWINE_DRIVER       lpDrv = NULL;
+    LPCSTR              lpSFN;
+    HMODULE             hModule;
+    DRIVERPROC          lpProc;
+    
+    dprintf(("'Entering DRIVER_TryOpenDriver32: %s', %08lX, %d);\n", lpFileName, lParam, bCallFrom32));
+    
+    if (strlen(lpFileName) < 1) 
+      return 0;
+    
+    lpSFN = strrchr(lpFileName, '\\');
+    lpSFN = (lpSFN) ? (lpSFN + 1) : lpFileName;
+    
+    if ((hModule = LoadLibraryA(lpFileName)) != 0) {
+      if ((lpProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc")) != NULL) {
+        lpDrv = DRIVER_RegisterDriver32(lpSFN, hModule, lpProc, lParam, bCallFrom32);
+      } else {
+            FreeLibrary(hModule);
+            lpDrv = 0;
+            dprintf(("DRIVER_TryOpenDriver32: No DriverProc found (line %d)\n",__LINE__));
+      }
+    } else {
+      dprintf(("DRIVER_TryOpenDriver32: Unable to load 32 bit module \"%s\" (line %d)\n", lpFileName,__LINE__));
+    }
+
+    dprintf(("(DRIVER_TryOpenDriver32) driver handle => %p\n", lpDrv));
+
+    return (HDRVR)lpDrv;
+}
+
+/**************************************************************************
+ *                              DRIVER_OpenDriverA                      [internal]
+ * (0,1,DRV_LOAD  ,0       ,0)
+ * (0,1,DRV_ENABLE,0       ,0)
+ * (0,1,DRV_OPEN  ,buf[256],0)
+ *
+ */
+static HDRVR  DRIVER_OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam) 
+{
+  HDRVR                 hDriver = 0;
+  char          drvName[128];
+  
+  dprintf(("Entering DRIVER_OpenDriverA: lpDriverName: %s lpSectionName: %s\n",lpDriverName,lpSectionName));
+
+  if (lpSectionName == NULL) {
+        lstrcpynA(drvName, lpDriverName, sizeof(drvName));
+        hDriver = DRIVER_TryOpenDriver32(lpDriverName, lParam, TRUE);
+        if (!hDriver) {
+      if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
+                                   sizeof(drvName), "SYSTEM.INI")) {
+
+                hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);                
+      }
+        }
+  } else {/* of if (lpSectionName == NULL) */
+    //dprintf(("driver name %x '%s'\n",drvName,drvName));
+    drvName[0]=0;    
+
+        if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
+                                 sizeof(drvName)-1, "SYSTEM.INI")) {
+#if 0
+      dprintf(("driver name %x '%s'\n",drvName,drvName));
+#endif      
+      hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);
+        }/* GetPrivate... */
+  }
+  if (!hDriver)
+        dprintf(("OpenDriverA: Failed to open driver %s from section %s\n", lpDriverName, lpSectionName));
+
+  else 
+        dprintf(("OpenDriverA success: Driver handle => %08x\n", hDriver));
+
+  return hDriver;
+}
+
+/**************************************************************************
+ *                              DRIVER_CloseDriver              [internal]
+ *
+ *
+ */
+static BOOL DRIVER_CloseDriver(LPWINE_DRIVER lpDrv, DWORD lParam1, DWORD lParam2)
+{
+  if (lpDrv != NULL) {
+        SendDriverMessage((HDRVR)lpDrv, DRV_CLOSE, lParam1, lParam2);
+    
+        if (DRIVER_RemoveFromList(lpDrv)) {
+      HeapFree(GetProcessHeap(), 0, lpDrv);
+      return TRUE;
+        }
+  }
+  dprintf(("Failed to close driver\n"));
+  return FALSE;
+}
+
+
+
+
+
+
+
+
+
+
+
+

trunk/src/winmm/initterm.cpp

@@ -1 @@
-/* $Id: initterm.cpp,v 1.10 2000-08-11 10:56:27 sandervl Exp $ */
+/* $Id: initterm.cpp,v 1.11 2000-12-03 22:18:17 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Peter Fitzsimmons
+ * Copyright 2000 Chris Wohlgemuth
  *
  *
@@ -42 +43 @@
 #include "dbglocal.h"
 
+BOOL MULTIMEDIA_MciInit(void);
+BOOL    MULTIMEDIA_CreateIData(HINSTANCE hinstDLL);
+void MULTIMEDIA_DeleteIData(void);
+
 extern "C" {
 void IRTMidiShutdown();  // IRTMidi shutdown routine
 void CDECL _ctordtorInit( void );
 void CDECL _ctordtorTerm( void );
+
 
  //Win32 resource table (produced by wrc)
@@ -56 +62 @@
 BOOL WINAPI LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
 {
-   switch (fdwReason)
-   {
-   case DLL_PROCESS_ATTACH:
+  static BOOL                   bInitDone = FALSE;
+  
+  switch (fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+      if (!MULTIMEDIA_CreateIData(hinstDLL))
+        return FALSE;
+      
+      if (!bInitDone) { /* to be done only once */
+            if (!MULTIMEDIA_MciInit() /*|| !MMDRV_Init() */ ) {
+          MULTIMEDIA_DeleteIData();
+          return FALSE;
+            }
+        bInitDone = TRUE;       
+      }
+      
         return TRUE;
 
@@ -66 +85 @@
 
    case DLL_PROCESS_DETACH:
+     MULTIMEDIA_DeleteIData();
         auxOS2Close(); /* SvL: Close aux device if necessary */
         IRTMidiShutdown;  /* JT: Shutdown RT Midi subsystem, if running. */
@@ -101 +121 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
          if(dllHandle == 0) 
-                return 0UL;
+           return 0UL;/* Error */
 
          break;
@@ -123 +143 @@
 //******************************************************************************
 //******************************************************************************
+
+
+

trunk/src/winmm/mci.cpp

@@ -1 @@
-/* $Id: mci.cpp,v 1.5 2000-02-17 14:09:31 sandervl Exp $ */
+/* $Id: mci.cpp,v 1.6 2000-12-03 22:18:17 sandervl Exp $ */
 
 /*
- * MCI stubs
+ * MCI functions
  *
  * Copyright 1998 Joel Troster
- *
+ * Copyright 1998/1999 Eric Pouech
+ * Copyright 2000 Chris Wohlgemuth
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -15 +16 @@
  * Includes                                                                 *
  ****************************************************************************/
+
+#define  INCL_BASE
+#define  INCL_OS2MM
 
 #include <os2win.h>
@@ -21 +25 @@
 #include <string.h>
 #include <stdio.h>
+#include "debugtools.h" 
 
 #include <misc.h>
 #include <unicode.h>
 
+#include "mcimm.h"
+
 #include "winmm.h"
 
 #define DBG_LOCALLOG    DBG_mci
+
 #include "dbglocal.h"
+
+
+/****************************************************************************
+ * Local functions                                                          *
+ ****************************************************************************/
+
+/* forward declaration */
+static DWORD  MCI_SendCommand(UINT mciId,
+              UINT16 uMsg,
+              DWORD dwParam1,
+              DWORD dwParam2);
+
+static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) ;
+static UINT     MCI_GetDriverFromString(LPCSTR lpstrName);
+
+/****************************************************************************/
 
 ODINDEBUGCHANNEL(WINMM-MCI)
@@ -38 +62 @@
               UINT, uStatus)
 {
-  dprintf(("WINMM:mciDriverNotify - stub\n"));
-  return FALSE;
+  TRACE("Entering mciDriverNotify (%08X, %04x, %04X)\n", hwndCallback, uDeviceID, uStatus);
+  
+  if (!IsWindow(hwndCallback)) {
+        WARN("bad hwnd for call back (0x%04x)\n", hwndCallback);
+        return FALSE;
+  }
+  TRACE("before PostMessage\n");
+  PostMessageA(hwndCallback, MM_MCINOTIFY, uStatus, uDeviceID);
+  return TRUE;
 }
 
@@ -73 +104 @@
               LPCSTR, pszDevice)
 {
-  dprintf(("WINMM:mciGetDeviceIDA - stub\n"));
-  return 0;
+  WARN(("WINMM:mciGetDeviceIDA - untested\n"));
+  return MCI_GetDriverFromString(pszDevice);
 }
 
@@ -100 +131 @@
 }
 
+/*****************************************************************************
+ *             Queries driver data
+ * Parameters: UINT uDeviceID
+ * Variables :
+ * @return   :  Pointer to driver data (as a DWORD)
+ * Remark    :
+ * @status   : Completely
+ *
+ * @author   : Chris Wohlgemuth [Sun, 2000/11/19]
+ *****************************************************************************/
 ODINFUNCTION1(DWORD, mciGetDriverData,
               UINT, uDeviceID)
 {
-  dprintf(("WINMM:mciGetDriverData - stub\n"));
-  return 0;
-}
-
+  LPWINE_MCIDRIVER      wmd;
+  
+  wmd = MCI_GetDriver(uDeviceID);
+  
+  if (!wmd) {
+        dprintf(("WARNING: Bad uDeviceID (mciGetDriverData (mci.cpp line %d)\n",__LINE__));
+    return 0L; /* Error */
+  }
+    
+  return wmd->dwPrivate;
+}
+
+/*****************************************************************************
+ *             Converts an error to an error string
+ * Parameters: MCIERROR mcierr,
+ *             LPSTR pszText,
+ *             UINT cchText
+ * Variables :
+ * @return   : API returncode (TRUE/FALSE)
+ * Remark    :
+ * @status   : Completely
+ *
+ * @author   : Wine
+ *****************************************************************************/
 ODINFUNCTION3(BOOL, mciGetErrorStringA,
               MCIERROR, mcierr,
@@ -125 +186 @@
 }
 
+/*****************************************************************************
+ *             Converts an error to an error string
+ * Parameters: MCIERROR mcierr,
+ *             LPSTR pszText,
+ *             UINT cchText
+ * Variables :
+ * @return   : API returncode (TRUE/FALSE)
+ * Remark    :
+ * @status   : Completely
+ *
+ * @author   : Wine
+ *****************************************************************************/
 ODINFUNCTION3(BOOL, mciGetErrorStringW,
               MCIERROR, mcierr,
@@ -143 +216 @@
 }
 
+/*****************************************************************************
+ *             Converts an error to an error string
+ * Parameters: MCIERROR mcierr,
+ *             LPSTR pszText,
+ *             UINT cchText
+ * Variables :
+ * @return    : API returncode
+ * Remark    :
+ * @status    : Completely
+ *
+ * @author    : Wine
+ *****************************************************************************/
 ODINFUNCTION2(YIELDPROC, mciGetYieldProc,
               MCIDEVICEID, mciId,
               LPDWORD, pdwYieldData)
 {
-  dprintf(("WINMM:mciGetYieldProc - stub\n"));
-  return 0;
+  LPWINE_MCIDRIVER      wmd;
+  
+  TRACE("Entering mciGetYieldProc (%u, %p) - untested\n", mciId, pdwYieldData);
+
+  if (!(wmd = MCI_GetDriver(mciId))) {
+        WARN("Bad uDeviceID\n");
+        return NULL;
+  }
+  if (!wmd->lpfnYieldProc) {
+        WARN("No proc set\n");
+        return NULL;
+  }
+  if (!wmd->bIs32) {
+        WARN("Proc is 32 bit\n");
+        return NULL;
+  }
+  return wmd->lpfnYieldProc;
 }
 
@@ -159 +259 @@
   return 0;
 }
+
 
 ODINFUNCTION4(MCIERROR, mciSendCommandA,
@@ -166 +267 @@
               DWORD, dwParam2)
 {
-  dprintf(("WINMM:mciSendCommandA - stub %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
-  return(MMSYSERR_NODRIVER);
-}
+  DWORD dwRet;
+  //  dprintf(("WINMM:mciSendCommandA - entering %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
+  dwRet= MCI_SendCommand((UINT) mciId,  uMsg,  dwParam1, dwParam2) & 0xFFFF;      
+  return(dwRet);
+}
+
 
 ODINFUNCTION4(MCIERROR, mciSendCommandW,
@@ -187 +291 @@
 {
   dprintf(("WINMM:mciSendStringA - stub\n"));
+  if(lpstrCommand)
+    dprintf(("WINMM:mciSendStringA command: %s\n",lpstrCommand));
   return(MMSYSERR_NODRIVER);
 }
@@ -204 +310 @@
               DWORD, dwData)
 {
-  dprintf(("WINMM:mciSetDriverData - stub\n"));
-  return FALSE;
-}
+  LPWINE_MCIDRIVER      wmd;
+  
+  wmd = MCI_GetDriver(uDeviceID);
+
+  if (!wmd) {
+        dprintf(("WARNING: Bad uDeviceID (mciSetDriverData line %d)\n",__LINE__));
+        return FALSE;
+  }
+  
+  wmd->dwPrivate = dwData;
+  return TRUE;
+}
+
 
 ODINFUNCTION3(BOOL, mciSetYieldProc,
@@ -213 +329 @@
               DWORD, dwYieldData)
 {
-  dprintf(("WINMM:mciSetYieldProc - stub\n"));
-  return FALSE;
-}
-
-
+  LPWINE_MCIDRIVER      wmd;
+  
+  TRACE("WINMM:mciSetYieldProc (%u, %p, %08lx) - untested\n", mciId, fpYieldProc, dwYieldData);
+  
+  if (!(wmd = MCI_GetDriver(mciId))) {
+        WARN("Bad uDeviceID\n");
+        return FALSE;
+  }
+  
+  wmd->lpfnYieldProc = fpYieldProc;
+  wmd->dwYieldData   = dwYieldData;
+  wmd->bIs32         = TRUE;
+  
+  return TRUE;
+}
+
+
+/**************************************************************************/
+/*                       heap.c                                           */
+/**************************************************************************/
+
+#ifdef __GNUC__
+#define GET_EIP()    (__builtin_return_address(0))
+#define SET_EIP(ptr) ((ARENA_INUSE*)(ptr) - 1)->callerEIP = GET_EIP()
+#else
+#define GET_EIP()    0
+#define SET_EIP(ptr) /* nothing */
+#endif  /* __GNUC__ */
+
+/***********************************************************************
+ *           HEAP_strdupA
+ */
+static LPSTR HEAP_strdupA( HANDLE heap, DWORD flags, LPCSTR str )
+{
+    LPSTR p = (LPSTR) HeapAlloc( heap, flags, strlen(str) + 1 );
+    if(p) {
+      //SET_EIP(p);
+      strcpy( p, str );
+    }
+    return p;
+}
+
+
+/**************************************************************************/
+/*                     mmmsystem.c                                        */
+/**************************************************************************/
+
+static LPWINE_MM_IDATA          lpFirstIData = NULL;
+
+static  LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void)
+{
+    DWORD               pid = GetCurrentProcessId();
+    LPWINE_MM_IDATA     iData;
+
+    for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
+      if (iData->dwThisProcess == pid)
+            break;
+    }
+    return iData;
+}
+
+/**************************************************************************
+ *                      MULTIMEDIA_GetIData                     [internal]
+ */
+LPWINE_MM_IDATA MULTIMEDIA_GetIData(void)
+{
+    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
+
+    if (!iData) {
+      dprintf(("MULTIMEDIA_GetIData: IData not found for pid=%08lx. Suicide !!!\n", GetCurrentProcessId()));
+      ExitProcess(0);
+    }
+    return iData;
+}
+
+
+/**************************************************************************
+ *                      MULTIMEDIA_CreateIData                  [internal]
+ */
+BOOL MULTIMEDIA_CreateIData(HINSTANCE hInstDLL)
+{
+    LPWINE_MM_IDATA     iData;
+        
+    iData = (LPWINE_MM_IDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA));
+
+    if (!iData)
+      return FALSE;
+    iData->hWinMM32Instance = hInstDLL;
+    iData->dwThisProcess = GetCurrentProcessId();
+    iData->lpNextIData = lpFirstIData;
+    lpFirstIData = iData;
+    InitializeCriticalSection(&iData->cs);
+    dprintf(("Created IData (%p) for pid %08lx\n", iData, iData->dwThisProcess));
+    return TRUE;
+}
+
+
+/**************************************************************************
+ *                      MULTIMEDIA_DeleteIData                  [internal]
+ */
+void MULTIMEDIA_DeleteIData(void)
+{
+    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
+    LPWINE_MM_IDATA*    ppid;
+            
+    if (iData) {
+        for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
+            if (*ppid == iData) {
+                *ppid = iData->lpNextIData;
+                break;
+            }
+        }
+        /* FIXME: should also free content and resources allocated 
+         * inside iData */
+        HeapFree(GetProcessHeap(), 0, iData);
+    }
+}
+
+
+/**************************************************************************/
+/*                     mmmsystem.c                                        */
+/**************************************************************************/
+
+
+static  int                     MCI_InstalledCount;
+static  LPSTR                   MCI_lpInstallNames = NULL;
+
+
+/* First MCI valid device ID (0 means error) */
+#define MCI_MAGIC 0x0001
+
+
+/**************************************************************************
+ *                              MCI_GetDriver                   [internal]
+ */
+static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) 
+{
+    LPWINE_MCIDRIVER    wmd = 0;
+    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
+
+    EnterCriticalSection(&iData->cs);
+    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
+        if (wmd->wDeviceID == wDevID)
+            break;
+    }
+    LeaveCriticalSection(&iData->cs);
+    return wmd;
+}
+
+/**************************************************************************
+ *                              MCI_GetDriverFromString         [internal]
+ */
+static UINT     MCI_GetDriverFromString(LPCSTR lpstrName)
+{
+    LPWINE_MCIDRIVER    wmd;
+    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
+    UINT                ret = 0;
+
+    if (!lpstrName)
+      return 0;
+    
+    if (!lstrcmpiA(lpstrName, "ALL"))
+      return MCI_ALL_DEVICE_ID;
+    
+    EnterCriticalSection(&iData->cs);
+    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
+      if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
+            ret = wmd->wDeviceID;
+            break;
+      }
+      
+      if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) {
+            ret = wmd->wDeviceID;
+            break;
+      }
+      
+      if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) {
+            ret = wmd->wDeviceID;
+            break;
+      }
+    }
+    LeaveCriticalSection(&iData->cs);
+    
+    return ret;
+}
+
+
+/**************************************************************************
+ *                              MCI_GetDevTypeFromFileName      [internal]
+ */
+static  DWORD   MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
+{
+    LPSTR       tmp;
+
+    if ((tmp = strrchr(fileName, '.'))) {
+      GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
+      if (strcmp(buf, "*") != 0) {
+            return 0;
+      }
+      dprintf(("No [mci extensions] entry for '%s' found. MCI_GetDevTypeFromFileName: line %d, file 'mci.cpp'\n", tmp, __LINE__));
+    }
+    return MCIERR_EXTENSION_NOT_FOUND;
+}
+
+
+#define MAX_MCICMDTABLE                 20
+#define MCI_COMMAND_TABLE_NOT_LOADED    0xFFFE
+
+
+
+/**************************************************************************
+ *                              MCI_DefYieldProc                [internal]
+ */
+//UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
+
+UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data)
+{
+  INT16 ret;
+
+#if 0  
+  dprintf(("(0x%04x, 0x%08lx)\n", wDevID, data));
+#endif  
+  if ((HIWORD(data) != 0 && GetActiveWindow() != HIWORD(data)) ||
+      (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
+        /* WINE stuff removed: UserYield16();*/
+        ret = 0;
+  } else {
+        MSG             msg;
+    
+        msg.hwnd = HIWORD(data);
+        while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
+        ret = -1;
+  }
+  return ret;
+}
+
+
+/**************************************************************************
+ *                              MCI_UnLoadMciDriver             [internal]
+ */
+static  BOOL    MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
+{
+    LPWINE_MCIDRIVER*           tmp;
+
+#if 0
+    dprintf(("Entering MCI_UnLoadMciDriver...\n"));
+#endif
+    if (!wmd)
+      return TRUE;
+
+    if (wmd->hDrv) 
+      CloseDriver(wmd->hDrv, 0, 0);
+
+    if (wmd->dwPrivate != 0)
+      dprintf(("Unloading mci driver with non nul dwPrivate field\n"));
+
+    EnterCriticalSection(&iData->cs);
+    for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
+      if (*tmp == wmd) {
+            *tmp = wmd->lpNext;
+            break;
+      }
+    }
+    LeaveCriticalSection(&iData->cs);
+
+    HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
+    HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);
+    HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName);
+
+    HeapFree(GetProcessHeap(), 0, wmd);
+    //dprintf(("Leaving MCI_UnLoadMciDriver...\n"));
+    return TRUE;
+}
+
+/**************************************************************************
+ *                              MCI_LoadMciDriver               [internal]
+ */
+static  DWORD   MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp, 
+                                  LPWINE_MCIDRIVER* lpwmd)
+{
+    LPSTR                       strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
+    LPWINE_MCIDRIVER            wmd = (LPWINE_MCIDRIVER)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
+    MCI_OPEN_DRIVER_PARMSA      modp;
+    DWORD                       dwRet = 0;
+    HDRVR                       hDrv = 0;
+
+
+    dprintf(("Entering MCI_LoadMciDriver...\n"));
+ 
+    if (!wmd || !strDevTyp) {
+      dwRet = MCIERR_OUT_OF_MEMORY;
+      goto errCleanUp;
+    }
+
+    wmd->lpstrDeviceType = strDevTyp;
+    wmd->lpfnYieldProc = MCI_DefYieldProc;
+    wmd->dwYieldData = VK_CANCEL;
+    wmd->hCreatorTask = NULL;
+
+
+    EnterCriticalSection(&iData->cs);
+    /* wmd must be inserted in list before sending opening the driver, coz' it
+     * may want to lookup at wDevID
+     */
+    wmd->lpNext = iData->lpMciDrvs;
+    iData->lpMciDrvs = wmd;
+
+    for (modp.wDeviceID = MCI_MAGIC; 
+         MCI_GetDriver(modp.wDeviceID) != 0; 
+         modp.wDeviceID++);
+
+    wmd->wDeviceID = modp.wDeviceID;
+
+    LeaveCriticalSection(&iData->cs);
+
+    dprintf(("wDevID=%04X strDevTyp: %s\n", modp.wDeviceID, strDevTyp));
+
+    modp.lpstrParams = NULL;
+
+    hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
+    
+    if (!hDrv) {
+      dprintf(("Couldn't load driver for type %s.\n"
+               "If you don't have a windows installation accessible from Wine,\n"
+               "you perhaps forgot to create a [mci] section in system.ini\n",
+               strDevTyp));
+      dwRet = MCIERR_DEVICE_NOT_INSTALLED;
+      goto errCleanUp;
+    }                           
+
+    /* FIXME: should also check that module's description is of the form
+     * MODULENAME:[MCI] comment
+     */
+
+    wmd->hDrv = hDrv;
+    /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
+    wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
+    wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
+
+    dprintf(("Loaded driver %x (%s), type is %d, cmdTable=%08x\n", 
+          hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable));
+    
+    
+    wmd->wType = modp.wType;
+
+#if 0    
+    dprintf(("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", 
+             modp.wDeviceID, modp.wType, modp.wDeviceID));
+#endif
+
+    *lpwmd = wmd;
+#if 0
+    dprintf(("Leaving MCI_LoadMciDriver succesful...\n"));
+#endif
+    return 0;
+errCleanUp:
+    MCI_UnLoadMciDriver(iData, wmd);
+    //  HeapFree(GetProcessHeap(), 0, strDevTyp);<-- done in MCI_UnloadMciDriver
+    *lpwmd = 0;
+    dprintf(("Leaving MCI_LoadMciDriver on error...\n"));
+    return dwRet;
+}
+
+
+/**************************************************************************
+ *                      MCI_SendCommandFrom32                   [internal]
+ */
+static DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
+{
+    DWORD               dwRet = MCIERR_DEVICE_NOT_INSTALLED;
+    LPWINE_MCIDRIVER    wmd = MCI_GetDriver(wDevID);
+
+    if (!wmd) {
+      dwRet = MCIERR_INVALID_DEVICE_ID;
+    } else {
+      switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST)) {
+      case WINE_GDF_EXIST:
+            dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
+            break;
+      default:
+            dprintf(("Unknown driver %u\n", wmd->hDrv));
+            dwRet = MCIERR_DRIVER_INTERNAL;
+      }
+    }
+    return dwRet;
+}
+    
+/**************************************************************************
+ *                      MCI_FinishOpen                          [internal]
+ */
+static  DWORD   MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms, 
+                               DWORD dwParam)
+{
+  if (dwParam & MCI_OPEN_ELEMENT)
+        wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0, 
+                                         lpParms->lpstrElementName);
+  
+  if (dwParam & MCI_OPEN_ALIAS)
+        wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
+  
+  lpParms->wDeviceID = wmd->wDeviceID;
+  
+  return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam, 
+                               (DWORD)lpParms);
+}
+
+/**************************************************************************
+ *                      MCI_Open                                [internal]
+ */
+static  DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
+{
+    char                        strDevTyp[128];
+    DWORD                       dwRet; 
+    LPWINE_MCIDRIVER            wmd = NULL;
+
+    LPWINE_MM_IDATA             iData = MULTIMEDIA_GetIData();
+
+    dprintf(("Entering MCI_OPEN...\n"));
+
+    if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
+
+    /* only two low bytes are generic, the other ones are dev type specific */
+#define WINE_MCIDRIVER_SUPP     (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
+                         MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
+                         MCI_NOTIFY|MCI_WAIT)
+    if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
+        dprintf(("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP));
+    }
+#undef WINE_MCIDRIVER_SUPP
+
+    strDevTyp[0] = 0;
+
+    if (dwParam & MCI_OPEN_TYPE) {
+      if (dwParam & MCI_OPEN_TYPE_ID) {
+            WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
+        if (uDevType < MCI_DEVTYPE_FIRST ||
+            uDevType > MCI_DEVTYPE_LAST ||
+            !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) /* This gets a name for the device e.g 'cdaudio' */
+          {
+            dwRet = MCIERR_BAD_INTEGER;
+            goto errCleanUp;
+          }
+      } else {
+            LPSTR       ptr;
+            if (lpParms->lpstrDeviceType == NULL) {
+          dwRet = MCIERR_NULL_PARAMETER_BLOCK;
+                goto errCleanUp;
+            }
+            strcpy(strDevTyp, lpParms->lpstrDeviceType);
+            ptr = strchr(strDevTyp, '!');
+            if (ptr) {
+                /* this behavior is not documented in windows. However, since, in
+                 * some occasions, MCI_OPEN handling is translated by WinMM into
+                 * a call to mciSendString("open <type>"); this code shall be correct
+                 */
+                if (dwParam & MCI_OPEN_ELEMENT) {
+                    dprintf(("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
+                        lpParms->lpstrElementName, strDevTyp));
+                    dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
+                    goto errCleanUp;
+                }
+                dwParam |= MCI_OPEN_ELEMENT;
+                *ptr++ = 0;
+                /* FIXME: not a good idea to write in user supplied buffer */
+                lpParms->lpstrElementName = ptr;
+            }
+                
+      }
+      dprintf(("MCI_OPEN (MCI_OPEN_TYPE): devType='%s' !\n", strDevTyp));
+    }
+   
+    if (dwParam & MCI_OPEN_ELEMENT) {
+      dprintf(("lpstrElementName='%s'\n", lpParms->lpstrElementName));
+
+      if (dwParam & MCI_OPEN_ELEMENT_ID) {
+            dprintf(("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n"));
+            dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
+            goto errCleanUp;
+      }
+
+      if (!lpParms->lpstrElementName) {
+            dwRet = MCIERR_NULL_PARAMETER_BLOCK;
+            goto errCleanUp;
+      }
+
+#if 0
+      /* Only working on my machine!! CW */
+      if(lpParms->lpstrElementName[0]=='N') {
+            dprintf(("Discarding drive N:\n"));
+        dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
+            goto errCleanUp;
+      }
+#endif
+      
+      /* type, if given as a parameter, supersedes file extension */
+      if (!strDevTyp[0] && 
+          MCI_GetDevTypeFromFileName(lpParms->lpstrElementName, 
+                                     strDevTyp, sizeof(strDevTyp))) {
+        if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
+          dwRet = MCIERR_EXTENSION_NOT_FOUND;
+          goto errCleanUp;
+        }
+        /* FIXME: this will not work if several CDROM drives are installed on the machine */
+        strcpy(strDevTyp, "CDAUDIO");
+      }
+    }
+    
+    if (strDevTyp[0] == 0) {
+      dprintf(("Couldn't load driver (MCI_Open line %d)\n",__LINE__));
+      dwRet = MCIERR_INVALID_DEVICE_NAME;
+      goto errCleanUp;
+    }
+
+    if (dwParam & MCI_OPEN_ALIAS) {
+      dprintf(("MCI_OPEN_ALIAS requested\n"));
+      if (!lpParms->lpstrAlias) {
+            dwRet = MCIERR_NULL_PARAMETER_BLOCK;
+            goto errCleanUp;
+      }
+      dprintf(("Alias='%s' !\n", lpParms->lpstrAlias));
+    }
+   
+    if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
+      goto errCleanUp;
+    }
+
+
+    if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
+      dprintf(("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet));
+      /* FIXME: is dwRet the correct ret code ? */
+      goto errCleanUp;
+    }
+
+
+    /* only handled devices fall through */
+    dprintf(("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet));
+
+    if (dwParam & MCI_NOTIFY)
+      // mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
+      dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__));
+
+    return 0;
+
+errCleanUp:
+
+    if (wmd) MCI_UnLoadMciDriver(iData, wmd);
+
+    if (dwParam & MCI_NOTIFY)
+      //  mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
+      dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__));
+ 
+    dprintf(("Leaving MCI_Open on error...\n"));
+    return dwRet;
+}
+
+
+/**************************************************************************
+ *                      MCI_Close                               [internal]
+ */
+static  DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
+{
+  DWORD         dwRet;
+  LPWINE_MCIDRIVER      wmd;
+  LPWINE_MM_IDATA       iData = MULTIMEDIA_GetIData();
+  
+  //dprintf(("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms));
+
+  if (wDevID == MCI_ALL_DEVICE_ID) {
+        LPWINE_MCIDRIVER        next;
+
+        EnterCriticalSection(&iData->cs);
+        /* 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 ?
+         */
+        for (wmd = iData->lpMciDrvs; wmd; ) {
+      next = wmd->lpNext;
+      MCI_Close(wmd->wDeviceID, dwParam, lpParms);
+      wmd = next;
+        }       
+        LeaveCriticalSection(&iData->cs);
+        return 0;
+  }
+
+  if (!(wmd = MCI_GetDriver(wDevID))) {
+        return MCIERR_INVALID_DEVICE_ID;
+  }
+
+  dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
+  
+  MCI_UnLoadMciDriver(iData, wmd);
+  
+  if (dwParam & MCI_NOTIFY)
+    dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Close (line %d)\n",__LINE__));
+    //  mciDriverNotify16(lpParms->dwCallback, wDevID,
+    //                (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
+  
+  return dwRet;
+}
+
+
+/**************************************************************************
+ *                      MCI_WriteString                         [internal]
+ */
+DWORD   MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
+{
+    DWORD       ret = 0;
+
+    if (lpSrcStr) {
+        if (dstSize <= strlen(lpSrcStr)) {
+            lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
+            ret = MCIERR_PARAM_OVERFLOW;
+        } else {
+            strcpy(lpDstStr, lpSrcStr);
+        }       
+    } else {
+        *lpDstStr = 0;
+    }
+    return ret;
+}
+
+
+/**************************************************************************
+ *                      MCI_Sysinfo                             [internal]
+ */
+static  DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
+{
+    DWORD               ret = MCIERR_INVALID_DEVICE_ID;
+    LPWINE_MCIDRIVER    wmd;
+    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
+
+    if (lpParms == NULL)                        return MCIERR_NULL_PARAMETER_BLOCK;
+
+    TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", 
+          uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
+    
+    switch (dwFlags & ~MCI_SYSINFO_OPEN) {
+    case MCI_SYSINFO_QUANTITY:
+      {
+            DWORD       cnt = 0;
+            
+            if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || 
+            lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
+          if (dwFlags & MCI_SYSINFO_OPEN) {
+                    TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
+                    EnterCriticalSection(&iData->cs);
+                    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
+              cnt++;
+                    }
+                    LeaveCriticalSection(&iData->cs);
+          } else {
+                    TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
+                    cnt = MCI_InstalledCount;
+          }
+            } else {
+          if (dwFlags & MCI_SYSINFO_OPEN) {
+                    TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", 
+                  lpParms->wDeviceType);
+                    EnterCriticalSection(&iData->cs);
+                    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
+              if (wmd->wType == lpParms->wDeviceType)
+                            cnt++;
+                    }
+                    LeaveCriticalSection(&iData->cs);
+          } else {
+                    TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", 
+                  lpParms->wDeviceType);
+                    FIXME("Don't know how to get # of MCI devices of a given type\n");
+                    cnt = 1;
+          }
+            }
+            *(DWORD*)lpParms->lpstrReturn = cnt;
+      }
+      TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
+      ret = MCI_INTEGER_RETURNED;
+      break;
+    case MCI_SYSINFO_INSTALLNAME:
+      TRACE("MCI_SYSINFO_INSTALLNAME \n");
+      if ((wmd = MCI_GetDriver(uDevID))) {
+            ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, 
+                              wmd->lpstrDeviceType);
+      } else {
+            *lpParms->lpstrReturn = 0;
+            ret = MCIERR_INVALID_DEVICE_ID;
+      }
+      TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+      break;
+    case MCI_SYSINFO_NAME:
+      TRACE("MCI_SYSINFO_NAME\n");
+      if (dwFlags & MCI_SYSINFO_OPEN) {
+            FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
+            ret = MCIERR_UNRECOGNIZED_COMMAND;
+      } else if (lpParms->dwNumber > MCI_InstalledCount) {
+            ret = MCIERR_OUTOFRANGE;
+      } else {
+            DWORD       count = lpParms->dwNumber;
+            LPSTR       ptr = MCI_lpInstallNames;
+        
+            while (--count > 0) ptr += strlen(ptr) + 1;
+            ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
+      }
+      TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
+      break;
+    default:
+      TRACE("Unsupported flag value=%08lx\n", dwFlags);
+      ret = MCIERR_UNRECOGNIZED_COMMAND;
+    }
+    return ret;
+}
+
+
+/**************************************************************************
+ *                      MCI_Break                               [internal]
+ */
+static  DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
+{
+    DWORD       dwRet = 0;
+    
+    if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
+
+    if (dwFlags & MCI_NOTIFY)
+      dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Break (line %d)\n",__LINE__));
+    //  mciDriverNotify16(lpParms->dwCallback, wDevID,
+    //    (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
+
+    return dwRet;
+}
+
+    
+/**************************************************************************
+ *                      MCI_SendCommand                         [internal]
+ */
+static DWORD    MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, 
+                        DWORD dwParam2)
+{
+    DWORD               dwRet = MCIERR_UNRECOGNIZED_COMMAND;
+
+    switch (wMsg) {
+    case MCI_OPEN:
+      dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
+      break;
+    case MCI_CLOSE:
+      dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+      break;
+    case MCI_SYSINFO:
+      dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
+      break;
+    case MCI_BREAK:
+      dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
+      break;
+      // case MCI_SOUND:
+      /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
+       * but I couldn't get any doc on this MCI message
+       */
+      // break;
+    default:
+      if (wDevID == MCI_ALL_DEVICE_ID) {
+            dprintf(("MCI_SendCommand: unhandled MCI_ALL_DEVICE_ID\n"));
+            dwRet = MCIERR_CANNOT_USE_ALL;
+      } else {
+        dwRet=MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2);
+      }     
+      break;
+    }
+    return dwRet;
+}
+
+
+
+
+/**************************************************************************
+ *                      MULTIMEDIA_MciInit                      [internal]
+ *
+ * Initializes the MCI internal variables.
+ *
+ */
+BOOL MULTIMEDIA_MciInit(void)
+{
+    LPSTR       ptr1, ptr2;
+    HKEY        hWineConf;
+    HKEY        hkey;
+    DWORD       err;
+    DWORD       type;
+    DWORD       count = 2048;
+
+    MCI_InstalledCount = 0;
+    ptr1 = MCI_lpInstallNames = (char*) HeapAlloc(GetProcessHeap(), 0, count);
+
+    if (!MCI_lpInstallNames)
+      return FALSE;
+
+#if 0
+    /* FIXME: should do also some registry diving here ? */
+    if (!(err = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) &&
+        !(err = RegOpenKeyA(hWineConf, "options", &hkey))) {
+      err = RegQueryValueExA(hkey, "mci", 0, &type, MCI_lpInstallNames, &count);
+      RegCloseKey(hkey);
+      FIXME("Registry handling for mci drivers not changed for odin yet. Verbatim copy from WINE (line %d)",__LINE__);
+    }
+#endif
+    FIXME("No Registry querying for mci drivers yet! (line %d)",__LINE__);
+    err=1;
+    if (!err) {
+      TRACE("Wine => '%s' \n", ptr1);
+      while ((ptr2 = strchr(ptr1, ':')) != 0) {
+            *ptr2++ = 0;
+            TRACE("---> '%s' \n", ptr1);
+            MCI_InstalledCount++;
+            ptr1 = ptr2;
+      }
+      MCI_InstalledCount++;
+      TRACE("---> '%s' \n", ptr1);
+      ptr1 += strlen(ptr1) + 1;
+    } else {
+      GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI");
+      while (strlen(ptr1) > 0) {
+            TRACE("---> '%s' \n", ptr1);
+            ptr1 += strlen(ptr1) + 1;
+            MCI_InstalledCount++;
+      }
+    }
+    //RegCloseKey(hWineConf);
+    return TRUE;
+}

trunk/src/winmm/winmmrsrc.orc

@@ -1 @@
-/* $Id: winmmrsrc.orc,v 1.1 2000-03-06 23:39:17 bird Exp $ */
+/* $Id: winmmrsrc.orc,v 1.2 2000-12-03 22:18:19 sandervl Exp $ */
 
 #include "winuser.h"
 #include "odinrsrc.h"
+#include "mmddk.h"
+#include "winnls.h"
 
 
@@ -40 +42 @@
     END
 END
+
+
+/* Add your language specific defines here */
+#include "winmm_En.orc"
+#include "winmm_Fr.orc"
+#include "winmm_Nl.orc"
+#include "winmm_Pt.orc"
+#include "winmm_Es.orc"
+#include "winmm_Ru.orc"
+
+
+/* do not add NLS specific stuff below that line */
+
+CORE RCDATA
+BEGIN
+"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"type\0", 0x00002000L, MCI_STRING,
+"element\0", 0x00000200L, MCI_STRING,
+"alias\0", 0x00000400L, MCI_STRING,
+"shareable\0", 0x00000100L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"close\0", 0x00000804L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"from\0", 0x00000004L, MCI_INTEGER,
+"to\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"from\0", 0x00000004L, MCI_INTEGER,
+"to\0", 0x00000008L, MCI_INTEGER,
+"insert\0", 0x00000100L, MCI_FLAG,
+"overwrite\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"to start\0", 0x00000100L, MCI_FLAG,
+"to end\0", 0x00000200L, MCI_FLAG,
+"to\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"can record\0", 0x00000001L, MCI_INTEGER,
+"has audio\0", 0x00000002L, MCI_INTEGER,
+"has video\0", 0x00000003L, MCI_INTEGER,
+"uses files\0", 0x00000005L, MCI_INTEGER,
+"compound device\0", 0x00000006L, MCI_INTEGER,
+"device type\0", 0x00000004L, MCI_INTEGER,
+"can eject\0", 0x00000007L, MCI_INTEGER,
+"can play\0", 0x00000008L, MCI_INTEGER,
+"can save\0", 0x00000009L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"sysinfo\0", 0x00000810L, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"quantity\0", 0x00000100L, MCI_FLAG,
+"open\0", 0x00000200L, MCI_FLAG,
+"installname\0", 0x00000800L, MCI_FLAG,
+"name\0", 0x00000400L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"break\0", 0x00000811L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"on\0", 0x00000100L, MCI_INTEGER,
+"off\0", 0x00000400L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"sound\0", 0x00000812L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"save\0", 0x00000813L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_STRING,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"load\0", 0x00000850L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_STRING,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+VIDEODISC RCDATA
+BEGIN
+"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"from\0", 0x00000004L, MCI_INTEGER,
+"to\0", 0x00000008L, MCI_INTEGER,
+"fast\0", 0x00020000L, MCI_FLAG,
+"slow\0", 0x00100000L, MCI_FLAG,
+"speed\0", 0x00040000L, MCI_INTEGER,
+"reverse\0", 0x00010000L, MCI_FLAG,
+"scan\0", 0x00080000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"reverse\0", 0x00010000L, MCI_FLAG,
+"to start\0", 0x00000100L, MCI_FLAG,
+"to end\0", 0x00000200L, MCI_FLAG,
+"to\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"spin\0", 0x0000080cL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"up\0", 0x00010000L, MCI_FLAG,
+"down\0", 0x00020000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"reverse\0", 0x00020000L, MCI_FLAG,
+"by\0", 0x00010000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"frames\0", 0x00000003L, MCI_INTEGER,
+"hms\0", 0x00000001L, MCI_INTEGER,
+"track\0", 0x00004001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"speed\0", 0x00004002L, MCI_INTEGER,
+"forward\0", 0x00004003L, MCI_INTEGER,
+"media type\0", 0x00004004L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"side\0", 0x00004005L, MCI_INTEGER,
+"disc size\0", 0x00004006L, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"clv\0", 0x00010000L, MCI_FLAG,
+"cav\0", 0x00020000L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"can record\0", 0x00000001L, MCI_INTEGER,
+"has audio\0", 0x00000002L, MCI_INTEGER,
+"has video\0", 0x00000003L, MCI_INTEGER,
+"device type\0", 0x00000004L, MCI_INTEGER,
+"uses files\0", 0x00000005L, MCI_INTEGER,
+"compound device\0", 0x00000006L, MCI_INTEGER,
+"can eject\0", 0x00000007L, MCI_INTEGER,
+"can reverse\0", 0x00004002L, MCI_INTEGER,
+"can play\0", 0x00000008L, MCI_INTEGER,
+"can save\0", 0x00000009L, MCI_INTEGER,
+"fast play rate\0", 0x00004003L, MCI_INTEGER,
+"slow play rate\0", 0x00004004L, MCI_INTEGER,
+"normal play rate\0", 0x00004005L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"escape\0", 0x00000805L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_STRING,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"identity\0", 0x00000800L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+WAVEAUDIO RCDATA
+BEGIN
+"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"type\0", 0x00002000L, MCI_STRING,
+"element\0", 0x00000200L, MCI_STRING,
+"alias\0", 0x00000400L, MCI_STRING,
+"shareable\0", 0x00000100L, MCI_FLAG,
+"buffer\0", 0x00010000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"format tag\0", 0x00004001L, MCI_INTEGER,
+"channels\0", 0x00004002L, MCI_INTEGER,
+"samplespersec\0", 0x00004003L, MCI_INTEGER,
+"bytespersec\0", 0x00004004L, MCI_INTEGER,
+"alignment\0", 0x00004005L, MCI_INTEGER,
+"bitspersample\0", 0x00004006L, MCI_INTEGER,
+"input\0", 0x00400000L, MCI_INTEGER,
+"output\0", 0x00800000L, MCI_INTEGER,
+"level\0", 0x00004007L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"any input\0", 0x04000000L, MCI_FLAG,
+"any output\0", 0x08000000L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"bytes\0", 0x00000008L, MCI_INTEGER,
+"samples\0", 0x00000009L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"input\0", 0x00400000L, MCI_INTEGER,
+"output\0", 0x00800000L, MCI_INTEGER,
+"format tag\0", 0x00010000L, MCI_CONSTANT,
+"pcm\0", 0x00000001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"channels\0", 0x00020000L, MCI_INTEGER,
+"samplespersec\0", 0x00040000L, MCI_INTEGER,
+"bytespersec\0", 0x00080000L, MCI_INTEGER,
+"alignment\0", 0x00100000L, MCI_INTEGER,
+"bitspersample\0", 0x00200000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"can record\0", 0x00000001L, MCI_INTEGER,
+"has audio\0", 0x00000002L, MCI_INTEGER,
+"has video\0", 0x00000003L, MCI_INTEGER,
+"device type\0", 0x00000004L, MCI_INTEGER,
+"uses files\0", 0x00000005L, MCI_INTEGER,
+"compound device\0", 0x00000006L, MCI_INTEGER,
+"can eject\0", 0x00000007L, MCI_INTEGER,
+"can play\0", 0x00000008L, MCI_INTEGER,
+"can save\0", 0x00000009L, MCI_INTEGER,
+"inputs\0", 0x00004001L, MCI_INTEGER,
+"outputs\0", 0x00004002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"input\0", 0x00400000L, MCI_FLAG,
+"output\0", 0x00800000L, MCI_FLAG,
+"file\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"input\0", 0x00400000L, MCI_FLAG,
+"output\0", 0x00800000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"from\0", 0x00000004L, MCI_INTEGER,
+"to\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+CDAUDIO RCDATA
+BEGIN
+"atus\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"type\0", 0x00004001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"msf\0", 0x00000002L, MCI_INTEGER,
+"tmsf\0", 0x0000000aL, MCI_INTEGER,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"upc\0", 0x00000400L, MCI_FLAG,
+"identity\0", 0x00000800L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+SEQUENCER RCDATA
+BEGIN
+"atus\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"tempo\0", 0x00004002L, MCI_INTEGER,
+"port\0", 0x00004003L, MCI_INTEGER,
+"slave\0", 0x00004007L, MCI_INTEGER,
+"master\0", 0x00004008L, MCI_INTEGER,
+"offset\0", 0x00004009L, MCI_INTEGER,
+"division type\0", 0x0000400aL, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"smpte 30 drop\0", 0x00000007L, MCI_INTEGER,
+"smpte 30\0", 0x00000006L, MCI_INTEGER,
+"smpte 25\0", 0x00000005L, MCI_INTEGER,
+"smpte 24\0", 0x00000004L, MCI_INTEGER,
+"song pointer\0", 0x00004001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"tempo\0", 0x00010000L, MCI_INTEGER,
+"port\0", 0x00020000L, MCI_CONSTANT,
+"none\0", 0x0000fffdL, MCI_INTEGER,
+"mapper\0", 0x0000ffffL, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"slave\0", 0x00040000L, MCI_CONSTANT,
+"smpte\0", 0x00004004L, MCI_INTEGER,
+"midi\0", 0x00004003L, MCI_INTEGER,
+"none\0", 0x0000fffdL, MCI_INTEGER,
+"file\0", 0x00004002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"master\0", 0x00080000L, MCI_CONSTANT,
+"smpte\0", 0x00004004L, MCI_INTEGER,
+"midi\0", 0x00004003L, MCI_INTEGER,
+"none\0", 0x0000fffdL, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"offset\0", 0x01000000L, MCI_INTEGER,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"file\0", 0x00000200L, MCI_FLAG,
+"name\0", 0x00001000L, MCI_FLAG,
+"copyright\0", 0x00002000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+ANIMATION RCDATA
+BEGIN
+"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"type\0", 0x00002000L, MCI_STRING,
+"element\0", 0x00000200L, MCI_STRING,
+"alias\0", 0x00000400L, MCI_STRING,
+"shareable\0", 0x00000100L, MCI_FLAG,
+"style\0", 0x00010000L, MCI_CONSTANT,
+"overlapped\0", 0x00cf0000L, MCI_INTEGER,
+"popup\0", 0x80880000L, MCI_INTEGER,
+"child\0", 0x40000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"parent\0", 0x00020000L, MCI_INTEGER,
+"nostatic\0", 0x00040000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"play\0", 0x00000806L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"from\0", 0x00000004L, MCI_INTEGER,
+"to\0", 0x00000008L, MCI_INTEGER,
+"fast\0", 0x00040000L, MCI_FLAG,
+"slow\0", 0x00080000L, MCI_FLAG,
+"scan\0", 0x00100000L, MCI_FLAG,
+"reverse\0", 0x00020000L, MCI_FLAG,
+"speed\0", 0x00010000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"reverse\0", 0x00010000L, MCI_FLAG,
+"by\0", 0x00020000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"time format\0", 0x00000400L, MCI_CONSTANT,
+"milliseconds\0", 0x00000000L, MCI_INTEGER,
+"ms\0", 0x00000000L, MCI_INTEGER,
+"frames\0", 0x00000003L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"audio\0", 0x00000800L, MCI_CONSTANT,
+"all\0", 0x00000000L, MCI_INTEGER,
+"left\0", 0x00000001L, MCI_INTEGER,
+"right\0", 0x00000002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"video\0", 0x00001000L, MCI_FLAG,
+"on\0", 0x00002000L, MCI_FLAG,
+"off\0", 0x00004000L, MCI_FLAG,
+"door open\0", 0x00000100L, MCI_FLAG,
+"door closed\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"speed\0", 0x00004001L, MCI_INTEGER,
+"forward\0", 0x00004002L, MCI_INTEGER,
+"window handle\0", 0x00004003L, MCI_INTEGER,
+"palette handle\0", 0x00004004L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"time format\0", 0x00000006L, MCI_INTEGER,
+"current track\0", 0x00000008L, MCI_INTEGER,
+"stretch\0", 0x00004005L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"file\0", 0x00000200L, MCI_FLAG,
+"window text\0", 0x00010000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"can record\0", 0x00000001L, MCI_INTEGER,
+"has audio\0", 0x00000002L, MCI_INTEGER,
+"has video\0", 0x00000003L, MCI_INTEGER,
+"device type\0", 0x00000004L, MCI_INTEGER,
+"uses files\0", 0x00000005L, MCI_INTEGER,
+"compound device\0", 0x00000006L, MCI_INTEGER,
+"can eject\0", 0x00000007L, MCI_INTEGER,
+"can play\0", 0x00000008L, MCI_INTEGER,
+"can save\0", 0x00000009L, MCI_INTEGER,
+"can reverse\0", 0x00004001L, MCI_INTEGER,
+"fast play rate\0", 0x00004002L, MCI_INTEGER,
+"slow play rate\0", 0x00004003L, MCI_INTEGER,
+"normal play rate\0", 0x00004004L, MCI_INTEGER,
+"uses palettes\0", 0x00004006L, MCI_INTEGER,
+"can stretch\0", 0x00004007L, MCI_INTEGER,
+"windows\0", 0x00004008L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"normal\0", 0x00010000L, MCI_FLAG,
+"background\0", 0x00020000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"window\0", 0x00000841L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"handle\0", 0x00010000L, MCI_CONSTANT,
+"default\0", 0x00000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"state\0", 0x00040000L, MCI_CONSTANT,
+"hide\0", 0x00000000L, MCI_INTEGER,
+"minimize\0", 0x00000006L, MCI_INTEGER,
+"show\0", 0x00000005L, MCI_INTEGER,
+"maximized\0", 0x00000003L, MCI_INTEGER,
+"minimized\0", 0x00000002L, MCI_INTEGER,
+"iconic\0", 0x00000007L, MCI_INTEGER,
+"no action\0", 0x00000008L, MCI_INTEGER,
+"no activate\0", 0x00000004L, MCI_INTEGER,
+"normal\0", 0x00000001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"text\0", 0x00080000L, MCI_STRING,
+"stretch\0", 0x00100000L, MCI_FLAG,
+"fixed\0", 0x00200000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"put\0", 0x00000842L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"at\0", 0x00010000L, MCI_RECT,
+"source\0", 0x00020000L, MCI_FLAG,
+"destination\0", 0x00040000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"where\0", 0x00000843L, MCI_COMMAND_HEAD,
+"\0", 0x00000007L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"source\0", 0x00020000L, MCI_FLAG,
+"destination\0", 0x00040000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"update\0", 0x00000854L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"at\0", 0x00010000L, MCI_RECT,
+"hdc\0", 0x00020000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+OVERLAY RCDATA
+BEGIN
+"open\0", 0x00000803L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"type\0", 0x00002000L, MCI_STRING,
+"element\0", 0x00000200L, MCI_STRING,
+"alias\0", 0x00000400L, MCI_STRING,
+"shareable\0", 0x00000100L, MCI_FLAG,
+"style\0", 0x00010000L, MCI_CONSTANT,
+"overlapped\0", 0x00cf0000L, MCI_INTEGER,
+"popup\0", 0x80880000L, MCI_INTEGER,
+"child\0", 0x40000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"parent\0", 0x00020000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"status\0", 0x00000814L, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"position\0", 0x00000002L, MCI_INTEGER,
+"length\0", 0x00000001L, MCI_INTEGER,
+"number of tracks\0", 0x00000003L, MCI_INTEGER,
+"mode\0", 0x00000004L, MCI_INTEGER,
+"ready\0", 0x00000007L, MCI_INTEGER,
+"window handle\0", 0x00004001L, MCI_INTEGER,
+"media present\0", 0x00000005L, MCI_INTEGER,
+"stretch\0", 0x00004002L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"track\0", 0x00000010L, MCI_INTEGER,
+"start\0", 0x00000200L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
+"\0", 0x00000001L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"product\0", 0x00000100L, MCI_FLAG,
+"file\0", 0x00000200L, MCI_FLAG,
+"window text\0", 0x00010000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
+"\0", 0x00000002L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_CONSTANT,
+"can record\0", 0x00000001L, MCI_INTEGER,
+"has audio\0", 0x00000002L, MCI_INTEGER,
+"has video\0", 0x00000003L, MCI_INTEGER,
+"device type\0", 0x00000004L, MCI_INTEGER,
+"uses files\0", 0x00000005L, MCI_INTEGER,
+"compound device\0", 0x00000006L, MCI_INTEGER,
+"can eject\0", 0x00000007L, MCI_INTEGER,
+"can play\0", 0x00000008L, MCI_INTEGER,
+"can save\0", 0x00000009L, MCI_INTEGER,
+"can stretch\0", 0x00004001L, MCI_INTEGER,
+"can freeze\0", 0x00004002L, MCI_INTEGER,
+"windows\0", 0x00004003L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"window\0", 0x00000841L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"handle\0", 0x00010000L, MCI_CONSTANT,
+"default\0", 0x00000000L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"state\0", 0x00040000L, MCI_CONSTANT,
+"hide\0", 0x00000000L, MCI_INTEGER,
+"minimize\0", 0x00000006L, MCI_INTEGER,
+"show\0", 0x00000005L, MCI_INTEGER,
+"maximized\0", 0x00000003L, MCI_INTEGER,
+"minimized\0", 0x00000002L, MCI_INTEGER,
+"iconic\0", 0x00000007L, MCI_INTEGER,
+"no action\0", 0x00000008L, MCI_INTEGER,
+"no activate\0", 0x00000004L, MCI_INTEGER,
+"normal\0", 0x00000001L, MCI_INTEGER,
+"\0", 0x00000000L, MCI_END_CONSTANT,
+"text\0", 0x00080000L, MCI_STRING,
+"stretch\0", 0x00100000L, MCI_FLAG,
+"fixed\0", 0x00200000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"put\0", 0x00000842L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"at\0", 0x00010000L, MCI_RECT,
+"source\0", 0x00020000L, MCI_FLAG,
+"destination\0", 0x00040000L, MCI_FLAG,
+"frame\0", 0x00080000L, MCI_FLAG,
+"video\0", 0x00100000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"where\0", 0x00000843L, MCI_COMMAND_HEAD,
+"\0", 0x00000007L, MCI_RETURN,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"source\0", 0x00020000L, MCI_FLAG,
+"destination\0", 0x00040000L, MCI_FLAG,
+"frame\0", 0x00080000L, MCI_FLAG,
+"video\0", 0x00100000L, MCI_FLAG,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"save\0", 0x00000813L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_STRING,
+"at\0", 0x00010000L, MCI_RECT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"load\0", 0x00000850L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"\0", 0x00000100L, MCI_STRING,
+"at\0", 0x00010000L, MCI_RECT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"at\0", 0x00010000L, MCI_RECT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
+"notify\0", 0x00000001L, MCI_FLAG,
+"wait\0", 0x00000002L, MCI_FLAG,
+"at\0", 0x00010000L, MCI_RECT,
+"\0", 0x00000000L, MCI_END_COMMAND,
+"\0", 0x00000000L, MCI_END_COMMAND_LIST
+END
+
+STRINGTABLE
+BEGIN
+
+MCI_DEVTYPE_VCR,                "vcr"
+MCI_DEVTYPE_VIDEODISC,          "videodisc"
+MCI_DEVTYPE_OVERLAY,            "overlay"
+MCI_DEVTYPE_CD_AUDIO,           "cdaudio"
+MCI_DEVTYPE_DAT,                "dat"
+MCI_DEVTYPE_SCANNER,            "scanner"
+MCI_DEVTYPE_ANIMATION,          "animation"
+MCI_DEVTYPE_DIGITAL_VIDEO,      "digitalvideo"
+MCI_DEVTYPE_OTHER,              "other"
+MCI_DEVTYPE_WAVEFORM_AUDIO,     "waveaudio"
+MCI_DEVTYPE_SEQUENCER,          "sequencer"
+
+MCI_MODE_NOT_READY,             "not ready"
+MCI_MODE_STOP,                  "stopped"
+MCI_MODE_PLAY,                  "playing"
+MCI_MODE_RECORD,                "recording"
+MCI_MODE_SEEK,                  "seeking"
+MCI_MODE_PAUSE,                 "paused"
+MCI_MODE_OPEN,                  "open"
+MCI_FALSE,                      "false"
+MCI_TRUE,                       "true"
+MCI_FORMAT_MILLISECONDS_S,      "milliseconds"
+MCI_FORMAT_HMS_S,               "hms"
+MCI_FORMAT_MSF_S,               "msf"
+MCI_FORMAT_FRAMES_S,            "frames"
+MCI_FORMAT_SMPTE_24_S,          "smpte 24"
+MCI_FORMAT_SMPTE_25_S,          "smpte 25"
+MCI_FORMAT_SMPTE_30_S,          "smpte 30"
+MCI_FORMAT_SMPTE_30DROP_S,      "smpte 30 drop"
+MCI_FORMAT_BYTES_S,             "bytes"
+MCI_FORMAT_SAMPLES_S,           "samples"
+MCI_FORMAT_TMSF_S,              "tmsf"
+
+MCI_VD_MODE_PARK,               "parked"
+MCI_VD_MEDIA_CLV,               "CLV"
+MCI_VD_MEDIA_CAV,               "CAV"
+MCI_VD_MEDIA_OTHER              "other"
+
+MCI_VD_FORMAT_TRACK_S,          "track"
+
+MCI_SEQ_DIV_PPQN,               "PPQN"
+MCI_SEQ_DIV_SMPTE_24            "SMPTE 24 Frame"
+MCI_SEQ_DIV_SMPTE_25            "SMPTE 25 Frame"
+MCI_SEQ_DIV_SMPTE_30DROP        "SMPTE 30 Drop Frame"
+MCI_SEQ_DIV_SMPTE_30            "SMPTE 30 Frame"
+
+MCI_SEQ_FILE_S,                 "file"
+MCI_SEQ_MIDI_S,                 "midi"
+MCI_SEQ_SMPTE_S,                "smpte"
+MCI_SEQ_FORMAT_SONGPTR_S,       "song pointer"
+MCI_SEQ_NONE_S,                 "none"
+MCI_SEQ_MAPPER_S,               "mapper"
+WAVE_FORMAT_PCM_S,              "pcm"
+WAVE_MAPPER_S,                  "mapper"
+END
+
+
+
+
+
+
+
+
+
+
+
+