Changeset 4709 for trunk/src

Timestamp:

Dec 2, 2000, 12:37:34 PM (25 years ago)

Author:

sandervl

Message:

CW: Rewrote for OS/2

Location:

trunk/src/winmm/mcicda

Files:

• cdrom.cpp (modified) (2 diffs)
• cdrom.h (modified) (6 diffs)
• makefile (modified) (2 diffs)
• mcicda.cpp (modified) (34 diffs)
• mcicda.def (deleted)
• mcicda.rc (deleted)
• mcicdos2.def (added)
• mcicdos2rsrc.orc (added)
• os2cdrom.cpp (added)

trunk/src/winmm/mcicda/cdrom.cpp

@@ +1 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*
+ * MCI CDAUDIO Driver for OS/2. Interface to OS/2 DosIOCtrl()
+ *
+ * Copyright 2000    Chris Wohlgemuth
+ *
+ * Project Odin Software License can be found in LICENSE.TXT
+ *
+ */
+
+
 #include <os2win.h>
 #include "cdrom.h"
+#include <debugtools.h>
+#include <string.h>
+
+/* 
+ * FIXME: Should use the right errorcodes for SetLastError if a function fails.
+*/
 
 int     CDAUDIO_Open(WINE_CDAUDIO* wcda)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_Open not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-int     CDAUDIO_Close(WINE_CDAUDIO* wcda)
-{
-  dprintf(("MCICDA-CDROM: CDAUDIO_Close not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+  ULONG yyrc;
+  USHORT sel;
+  HFILE hFile;
+  int iNumCD;
+  char chrFirstCD[3]={0};
+  int i;
+
+  dprintf(("MCICDA-CDROM: Trying to open drive %s...\n",wcda->chrDrive));
+
+  if(strlen(wcda->chrDrive)==2) {
+      if((wcda->hfOS2Handle=os2CDOpen(wcda->chrDrive))==NULL) {
+          SetLastError(ERROR_WRONG_DISK);  
+          /* We always return TRUE because we want to open the driver not the disk */
+      }
+      return TRUE;
+  }
+
+  if(!strcmpi(wcda->chrDeviceType,"cdaudio")) {
+      /* We try any CDROM in the system until one can be opened */
+      if(!os2CDQueryCDDrives(&iNumCD,  chrFirstCD)) {
+          SetLastError(ERROR_WRONG_DISK);  
+          return FALSE;/* Can't get drives in system */
+      }
+      
+      chrFirstCD[1]=':';
+      for(i=0;i<iNumCD;i++) {
+          chrFirstCD[0]++;
+          if((wcda->hfOS2Handle=os2CDOpen(chrFirstCD))!=NULL) {     
+              return TRUE;
+          }
+      }
+      SetLastError(ERROR_WRONG_DISK);
+      /* We always return TRUE because we want to open the driver not the disk */  
+      /* Can't open CD */     
+  }
+  /* We always return TRUE because we want to open the driver not the disk */
+  return TRUE;
+}
+
+int CDAUDIO_Close(WINE_CDAUDIO* wcda)
+{
+    ULONG rc;
+    
+    dprintf(("MCICDA-CDROM: CDAUDIO_Close: Closing drive: %s...\n",wcda->chrDrive));
+    
+    if(wcda->hfOS2Handle==NULL) {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return FALSE;
+    }
+    
+  if((rc=os2CDClose(wcda->hfOS2Handle))!=0) {
+      dprintf(("MCICDA-CDROM: CDAUDIO_Close:rc=%d \n",rc));
+      SetLastError(ERROR_INVALID_PARAMETER);
+      return FALSE;
+  }
+  wcda->hfOS2Handle=NULL;
+  dprintf(("MCICDA-CDROM: CDAUDIO_Close: Drive %s closed\n",wcda->chrDrive));
+  return TRUE;
 }
 
@@ -25 +90 @@
 int     CDAUDIO_Play(WINE_CDAUDIO* wcda, DWORD start, DWORD stop)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_Play not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+    ULONG rc;
+
+    /* FIXME: error handling is missing */
+    //SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 1;
+        }
+    }
+
+    CDAUDIO_GetCDStatus(wcda);
+    if(wcda->cdaMode==WINE_CDA_PLAY||wcda->cdaMode==WINE_CDA_PAUSE)
+        CDAUDIO_Stop(wcda);
+    rc=os2CDPlayRange(wcda->hfOS2Handle , start, stop);
+    return 0;
 }
 
 int     CDAUDIO_Stop(WINE_CDAUDIO* wcda)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_Stop not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+    //  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    /* FIXME: error handling is missing */
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 1;
+        }
+    }
+
+    os2CDStop(wcda->hfOS2Handle);
+    return 0;
 }
 
 int     CDAUDIO_Pause(WINE_CDAUDIO* wcda, int pauseOn)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_Pause not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+
+    //SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    /* FIXME: error handling is missing */
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 1;
+        }
+    }
+
+    if(pauseOn)
+        os2CDStop(wcda->hfOS2Handle);
+    else
+        os2CDResume(wcda->hfOS2Handle);
+    return 0;
 }
 
 int     CDAUDIO_Seek(WINE_CDAUDIO* wcda, DWORD at)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_Seek not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+    /* FIXME: error handling is missing */
+  //SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 1;
+        }
+    }
+    
+    os2CDSeek(wcda->hfOS2Handle, at);
+    return 0;
 }
 
 int     CDAUDIO_SetDoor(WINE_CDAUDIO* wcda, int open)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_SetDoor not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-UINT16  CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO* wcda)
-{
-  dprintf(("MCICDA-CDROM: CDAUDIO_GetNumberOfTracks not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
+
+    /* FIXME: error handling is missing */
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 1;
+        }
+    }
+     
+    CDAUDIO_Stop(wcda);
+    if(open) {
+        os2CDEject(wcda->hfOS2Handle);
+    }
+    else
+        BOOL os2CDCloseTray(HFILE hfDrive);
+
+    return 0;
+}
+
+
+/******************************************/
+/* Result:  
+         0:   Error
+         -1: CD is Data Disk
+         other: # Audio tracks */
+/******************************************/
+int     CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO* wcda)
+{
+    int rcOS2;
+
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return 0;
+        }
+    }
+
+    rcOS2=os2GetNumTracks(wcda->hfOS2Handle,&wcda->ulLeadOut);
+    switch(rcOS2)
+        {
+        case -1:
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return -1;
+        case 0:
+            SetLastError(ERROR_WRONG_DISK);  
+            return -1;
+        default:
+            break;
+        }
+
+    wcda->nTracks=rcOS2;
+    wcda->nFirstTrack=1;
+    wcda->nLastTrack=rcOS2;
+    return rcOS2;
 }
 
 BOOL    CDAUDIO_GetTracksInfo(WINE_CDAUDIO* wcda)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_GetTracksInfo not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
+
+    int         i, length;
+    ULONG               start, last_start = 0;
+    int         total_length = 0;
+
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return FALSE;
+        }
+    }
+    
+    if (wcda->nTracks == 0) {
+        if (CDAUDIO_GetNumberOfTracks(wcda) <= 0)
+            return FALSE;
+    }
+    
+    TRACE("nTracks=%u\n", wcda->nTracks);
+    
+    SetLastError(ERROR_INVALID_PARAMETER);
+    
+    if (wcda->lpdwTrackLen != NULL) 
+        free(wcda->lpdwTrackLen);
+    wcda->lpdwTrackLen = (LPDWORD)malloc((wcda->nTracks + 1) * sizeof(DWORD));
+    if (wcda->lpdwTrackPos != NULL) 
+        free(wcda->lpdwTrackPos);
+    wcda->lpdwTrackPos = (LPDWORD)malloc((wcda->nTracks + 1) * sizeof(DWORD));
+    if (wcda->lpbTrackFlags != NULL)
+        free(wcda->lpbTrackFlags);
+    wcda->lpbTrackFlags = (LPBYTE)malloc((wcda->nTracks + 1) * sizeof(BYTE));
+    
+    if (wcda->lpdwTrackLen == NULL || wcda->lpdwTrackPos == NULL ||
+        wcda->lpbTrackFlags == NULL) {
+        WARN("error allocating track table !\n");
+        /* Freeing the already allocated mem */
+        if (wcda->lpdwTrackLen != NULL) 
+            free(wcda->lpdwTrackLen);
+        if (wcda->lpdwTrackPos != NULL) 
+            free(wcda->lpdwTrackPos);
+        if (wcda->lpbTrackFlags != NULL)
+            free(wcda->lpbTrackFlags);
+        wcda->lpbTrackFlags=NULL;
+        wcda->lpdwTrackPos=NULL;
+        wcda->lpdwTrackLen= NULL;
+        return FALSE;
+    }
+    memset(wcda->lpdwTrackLen, 0, (wcda->nTracks + 1) * sizeof(DWORD));
+    memset(wcda->lpdwTrackPos, 0, (wcda->nTracks + 1) * sizeof(DWORD));
+    memset(wcda->lpbTrackFlags, 0, (wcda->nTracks + 1) * sizeof(BYTE));
+    
+    for (i = 0; i <= wcda->nTracks; i++) {
+        if((start=os2CDQueryTrackStartSector(wcda->hfOS2Handle,i))==0)
+            {
+                WARN("error reading start sector for track %d\n", i+1);
+                /* Freeing the already allocated mem */
+                if (wcda->lpdwTrackLen != NULL) 
+                    free(wcda->lpdwTrackLen);
+                if (wcda->lpdwTrackPos != NULL) 
+                    free(wcda->lpdwTrackPos);
+                if (wcda->lpbTrackFlags != NULL)
+                    free(wcda->lpbTrackFlags);
+                wcda->lpbTrackFlags=NULL;
+                wcda->lpdwTrackPos=NULL;
+                wcda->lpdwTrackLen= NULL;
+                return FALSE;
+            }
+        start-=150;
+        
+        if (i == 0) {
+            last_start = start;
+            wcda->dwFirstFrame = start;
+            TRACE("dwFirstOffset=%u\n", start);
+        } else {
+            length = start - last_start;
+            last_start = start;
+            start = last_start - length;
+            total_length += length;
+            wcda->lpdwTrackLen[i - 1] = length;
+            wcda->lpdwTrackPos[i - 1] = start;
+            TRACE("track #%u start=%u len=%u\n", i, start, length);
+        }
+        //if(wcda->ulCDROMStatus & )
+        wcda->lpbTrackFlags[i] = 0; 
+        //TRACE("track #%u flags=%02x\n", i + 1, wcda->lpbTrackFlags[i]);
+    }/* for */
+    
+    wcda->dwLastFrame = last_start;
+    TRACE("total_len=%u Leaving CDAUDIO_GetTracksInfo...\n", total_length);
+    
+    return TRUE;
+    
+    dprintf(("MCICDA-CDROM: CDAUDIO_GetTracksInfo not implemented.\n"));
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
 
 BOOL    CDAUDIO_GetCDStatus(WINE_CDAUDIO* wcda)
 {
-  dprintf(("MCICDA-CDROM: CDAUDIO_GetCDStatus not implemented.\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-  return FALSE;
-}
-
-
+    ULONG ulRet;
+    int oldmode = wcda->cdaMode;
+
+    if(!wcda->hfOS2Handle) {
+        CDAUDIO_Open(wcda);/* Get new handle */
+        if(!wcda->hfOS2Handle) {
+            WARN("hfOS2Handle isn't valid and can't get new one\n");
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return FALSE;
+        }
+    }
+
+    if(!os2GetCDStatus(wcda->hfOS2Handle, &wcda->ulCDROMStatus)) {
+        WARN("os2GetCDStatus(wcda->hfOS2Handle, &wcda->ulCDROMStatus) returned FALSE\n");
+        return FALSE;
+    }
+    /* Current mode */    
+    //wcda->cdaMode=WINE_CDA_STOP;
+    if(wcda->ulCDROMStatus & 0x1L)
+        wcda->cdaMode=WINE_CDA_OPEN; /* Door open */
+    else if(wcda->ulCDROMStatus & 0x1000L)
+        wcda->cdaMode=WINE_CDA_PLAY; /* Playing */
+    else if(wcda->ulCDROMStatus & 0x800L)
+        wcda->cdaMode=WINE_CDA_NOTREADY;
+    else
+        wcda->cdaMode=WINE_CDA_STOP;
+
+    if(wcda->cdaMode==WINE_CDA_OPEN && wcda->hfOS2Handle) {
+        CDAUDIO_Close(wcda);
+        return FALSE;
+    }
+
+    if(!os2GetCDAudioStatus(wcda->hfOS2Handle, &wcda->usCDAudioStatus)) {
+        WARN("os2GetCDAudioStatus(wcda->hfOS2Handle, &wcda->usCDAudioStatus) returned FALSE rc=%x %d\n",wcda->usCDAudioStatus,wcda->usCDAudioStatus);
+        return FALSE;
+
+    }
+    else {
+        if(wcda->usCDAudioStatus & 1)
+            wcda->cdaMode=WINE_CDA_PAUSE;
+        os2CDGetHeadLocation(wcda->hfOS2Handle,&wcda->dwCurFrame);
+        os2CDQueryCurTrack(wcda->hfOS2Handle, &wcda->nCurTrack);
+    }
+
+    if (oldmode != wcda->cdaMode && oldmode == WINE_CDA_OPEN) {
+        TRACE("Updating TracksInfo !\n");
+        if (!CDAUDIO_GetTracksInfo(wcda)) {
+            WARN("error updating TracksInfo !\n");
+            return FALSE;
+        }
+    }
+
+    dprintf(("MCICDA-CDROM: Leaving CDAUDIO_GetCDStatus... cdaMode: %x\n",wcda->cdaMode));
+    if (wcda->cdaMode != WINE_CDA_OPEN)
+        return TRUE;
+    else 
+        return FALSE;
+}
+
+
+
+
+
+
+
+
+
+
+

trunk/src/winmm/mcicda/cdrom.h

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
 /*
- * Sample MCI CDAUDIO Wine Driver for Linux
+ * MCI CDAUDIO Driver for OS/2
  *
  * Copyright 1994 Martin Ayotte
  * Copyright 1999 Eric Pouech
+ * Copyright 2000 Chris Wohlgemuth
+ *
+ * Project Odin Software License can be found in LICENSE.TXT
  */
 
@@ -12 +15 @@
 #include <stdlib.h>
 // #include <unistd.h>
-#include "windef.h"
+//#include "windef.h"
 
 #ifdef HAVE_LINUX_CDROM_H
@@ -31 +34 @@
     struct cd_sub_channel_info  sc;
 #endif
+    char                        chrDrive[3];
+    char                        cPad;
+    char                        chrDeviceType[128];
+    ULONG                       hfOS2Handle;
+    ULONG                       ulLeadOut;
     /* those data reflect the cdaudio structure and
      * don't change while playing
@@ -43 +51 @@
     DWORD                       dwLastFrame;
     /* those data change while playing */
+    ULONG                       ulCDROMStatus;
+    USHORT                       usCDAudioStatus;
     int                         cdaMode;
-    UINT16                      nCurTrack;
+    UINT                        nCurTrack;
     DWORD                       dwCurFrame;
 } WINE_CDAUDIO;
+
+typedef struct {
+    UINT                wDevID;
+    int                 nUseCount;          /* Incremented for each shared open */
+    BOOL                fShareable;         /* TRUE if first open was shareable */
+    WORD                wNotifyDeviceID;    /* MCI device ID with a pending notification */
+    HANDLE              hCallback;          /* Callback handle for pending notification */
+    DWORD               dwTimeFormat;
+    WINE_CDAUDIO        wcda;
+    int                 mciMode;
+} WINE_MCICDAUDIO;
+
 
 #define WINE_CDA_DONTKNOW               0x00
@@ -54 +76 @@
 #define WINE_CDA_STOP                   0x04
 #define WINE_CDA_PAUSE                  0x05
+
+#ifndef MCI_CONFIGURE
+#define MCI_CONFIGURE                  0x087A
+#endif
 
 int     CDAUDIO_Open(WINE_CDAUDIO* wcda);
@@ -63 +89 @@
 int     CDAUDIO_Seek(WINE_CDAUDIO* wcda, DWORD at);
 int     CDAUDIO_SetDoor(WINE_CDAUDIO* wcda, int open);
-UINT16  CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO* wcda);
+int     CDAUDIO_GetNumberOfTracks(WINE_CDAUDIO* wcda);
 BOOL    CDAUDIO_GetTracksInfo(WINE_CDAUDIO* wcda);
 BOOL    CDAUDIO_GetCDStatus(WINE_CDAUDIO* wcda);
+
+HFILE os2CDOpen(char *drive);
+ULONG os2CDClose(ULONG hfOS2Handle);
+int os2GetNumTracks(HFILE hfOS2Handle,ULONG *ulLeadOut);
+BOOL os2GetCDStatus(HFILE hfOS2Handle, ULONG  *ulStatus);
+BOOL os2GetCDAudioStatus(HFILE hfOS2Handle, USHORT  *usStatus);
+ULONG  os2CDQueryTrackStartSector( HFILE hfDrive, ULONG numTrack);
+BOOL os2CDEject(HFILE hfDrive);
+BOOL os2CDCloseTray(HFILE hfDrive);
+BOOL os2CDStop(HFILE hfDrive);
+BOOL os2CDPlayRange(HFILE hfDrive ,ULONG ulFrom, ULONG ulTo);
+BOOL  os2CDResume(HFILE hfDrive);
+BOOL os2CDGetHeadLocation(HFILE hfOS2Handle, ULONG  *ulHeadLocation);
+BOOL os2CDSeek(HFILE hfOS2Handle, ULONG  ulTo);
+BOOL os2CDQueryCurTrack(HFILE hfOS2Handle, UINT  * uiCurTrack);
+BOOL os2CDQueryCDDrives(int *iNumCD, char * cFirstDrive);
 
 #define CDFRAMES_PERSEC                 75

trunk/src/winmm/mcicda/makefile

@@ -1 @@
-# $Id: makefile,v 1.3 2000-02-06 20:52:34 sandervl Exp $
+# $Id: makefile,v 1.4 2000-12-02 11:37:05 sandervl Exp $
 
 #
@@ -7 +7 @@
 #
 
+#
+# Directory macros.
+#
 PDWIN32_INCLUDE = ..\..\..\include
-PDWIN32_LIB = ..\..\..\lib
-PDWIN32_BIN = ..\..\..\bin
-PDWIN32_TOOLS = ..\..\..\tools\bin
+PDWIN32_LIB     = ..\..\..\lib
+PDWIN32_BIN     = ..\..\..\$(OBJDIR)
+PDWIN32_TOOLS   = ..\..\..\tools\bin
 
-
+#
+# Compiler, tools, and interference rules.
+#
 !include $(PDWIN32_INCLUDE)/pdwin32.mk
 
+#
+# Target name - name of the dll without extention and path.
+#
+TARGET = mcicdos2
 
-CFLAGS = $(CFLAGS) -I$(PDWIN32_INCLUDE)
-CXXFLAGS = $(CXXFLAGS) -I$(PDWIN32_INCLUDE)
+OBJS =  $(OBJDIR)\mcicda.obj \
+        $(OBJDIR)\cdrom.obj \
+        $(OBJDIR)\mcicdos2rsrc.obj \
+        $(PDWIN32_LIB)/dllentry.obj \
+        $(OBJDIR)\os2cdrom.obj 
 
-
-TARGET = mcicda
-
-OBJS =  mcicda.obj cdrom.obj resource.obj $(PDWIN32_LIB)/dllentry.obj
-
-all: $(TARGET).dll $(TARGET).lib
-
-
-$(TARGET).dll: $(OBJS) $(TARGET).def
-        $(LD) $(LDFLAGS) -Fm -Fe$@ $(OBJS) $(TARGET).def \
-              $(PDWIN32_LIB)/pmwinx.lib $(PDWIN32_LIB)/kernel32.lib \
-              $(PDWIN32_LIB)/user32.lib $(PDWIN32_LIB)/winmm.lib $(PDWIN32_LIB)/odincrt.lib OS2386.LIB $(RTLLIB_O)
-        $(CP) $@ $(PDWIN32_BIN)
-
-
-$(TARGET).lib: $(TARGET).def
-        $(IMPLIB) $(IMPLIBFLAGS) $@ $**
-        $(CP) $@ $(PDWIN32_LIB)
-
-resource.asm: $(TARGET).rc
-    $(RC) $(RCFLAGS) -o resource.asm $(TARGET).rc
-
-resource.obj: resource.asm
-
-mcicda.obj: mcicda.cpp
-
-cdrom.obj: cdrom.cpp
-
-clean:
-        $(RM) *.obj *.lib *.dll *.map *.pch
-        $(RM) $(PDWIN32_BIN)\$(TARGET).dll
-        $(RM) $(PDWIN32_LIB)\$(TARGET).lib
+#
+# Libraries. One space before the '\'.
+#
+LIBS = \
+$(PDWIN32_LIB)\WINMM.LIB \
+$(PDWIN32_LIB)/kernel32.lib \
+$(PDWIN32_LIB)/$(ODINCRT).lib \
+OS2386.LIB \
+$(RTLLIB_O)
 
 
 
-
-
+#
+# Includes the common rules.
+#
+!include $(PDWIN32_INCLUDE)/pdwin32.post

trunk/src/winmm/mcicda/mcicda.cpp

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
 /*
- * Sample MCI CDAUDIO Wine Driver for Linux
+ * MCI CDAUDIO Driver for OS/2
  *
  * Copyright 1994    Martin Ayotte
  * Copyright 1998-99 Eric Pouech
+ * Copyright 2000    Chris Wohlgemuth
+ *
+ * Project Odin Software License can be found in LICENSE.TXT
+ *
  */
 
@@ -10 +14 @@
 #include <string.h>
 #include "winuser.h"
-#include "driver.h"
+////#include "driver.h"
 #include "mmddk.h"
 #include "cdrom.h"
@@ -17 +21 @@
 DEFAULT_DEBUG_CHANNEL(cdaudio)
 
-typedef struct {
-    UINT                wDevID;
-    int                 nUseCount;          /* Incremented for each shared open */
-    BOOL                fShareable;         /* TRUE if first open was shareable */
-    WORD                wNotifyDeviceID;    /* MCI device ID with a pending notification */
-    HANDLE              hCallback;          /* Callback handle for pending notification */
-    DWORD               dwTimeFormat;
-    WINE_CDAUDIO        wcda;
-    int                 mciMode;
-} WINE_MCICDAUDIO;
 
 /*-----------------------------------------------------------------------*/
@@ -68 +62 @@
     WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
     
-    if (wmcda == NULL || wmcda->nUseCount == 0 || wmcda->wcda.unixdev <= 0) {
-        WARN("Invalid wDevID=%u\n", wDevID);
+    if (wmcda == NULL || wmcda->nUseCount == 0 /*|| wmcda->wcda.unixdev <= 0*/ ) {
+        WARN("CDAUDIO_mciGetOpenDrv(UINT wDevID): Invalid wDevID=%u\n", wDevID);
         return 0;
     }
@@ -81 +75 @@
 {
     switch (wcdaMode) {
-    case WINE_CDA_DONTKNOW:     return MCI_MODE_STOP;
-    case WINE_CDA_NOTREADY:     return MCI_MODE_STOP;
+    case WINE_CDA_DONTKNOW:     return MCI_MODE_STOP;/* 0x20d */
+    case WINE_CDA_NOTREADY:     return MCI_MODE_STOP;/* 0x20d */
     case WINE_CDA_OPEN:         return MCI_MODE_OPEN;
     case WINE_CDA_PLAY:         return MCI_MODE_PLAY;
-    case WINE_CDA_STOP:         return MCI_MODE_STOP;
+    case WINE_CDA_STOP:         return MCI_MODE_STOP;/* 0x20d */
     case WINE_CDA_PAUSE:        return MCI_MODE_PAUSE;
     default:
@@ -215 +209 @@
     MCI_SEEK_PARMS      seekParms;
 
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
+    dprintf(("CDAUDIO_mciOpen: (wDevID: %04X, dwFlags: %08lX, %p);\n", wDevID, dwFlags, lpOpenParms));
+    
     
     if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
@@ -239 +234 @@
             return MCIERR_NO_ELEMENT_ALLOWED;
         }
-        WARN("MCI_OPEN_ELEMENT %s ignored\n",lpOpenParms->lpstrElementName);
+        /* Cdplayer.exe puts the driveletter into lpOpenParms->lpstrElementName */
+        TRACE("CDAUDIO_mciOpen(): MCI_OPEN_ELEMENT: %s\n",lpOpenParms->lpstrElementName);
+
+        if(strlen(lpOpenParms->lpstrElementName)==2)
+            strcpy(wmcda->wcda.chrDrive,lpOpenParms->lpstrElementName);/* Save */
         /*return MCIERR_NO_ELEMENT_ALLOWED; 
           bon 19991106 allows cdplayer.exe to run*/
     }
+    else if (dwFlags & MCI_OPEN_TYPE) {/*MCI_OPEN_TYPE  0x00002000L*/
+        TRACE("CDAUDIO_mciOpen(): MCI_OPEN_TYPE: %s\n",lpOpenParms->lpstrDeviceType);
+        wmcda->wcda.chrDrive[0]=0; /* Mark that we don't have a drive */
+        if(lpOpenParms->lpstrDeviceType)
+            strncpy(wmcda->wcda.chrDeviceType,lpOpenParms->lpstrDeviceType,sizeof(wmcda->wcda.chrDeviceType)-1);
+        else
+            wmcda->wcda.chrDeviceType[0]=0;
+    }
 
     wmcda->wNotifyDeviceID = dwDeviceID;
-    if (CDAUDIO_Open(&wmcda->wcda) == -1) {
+
+
+    if (!CDAUDIO_Open(&wmcda->wcda)) {
+#if 0
+        /* We're always successful because we open the driver not the disk */
         --wmcda->nUseCount;
         return MCIERR_HARDWARE;
-    }
+#endif
+    }
+
     wmcda->mciMode = MCI_MODE_STOP;
     wmcda->dwTimeFormat = MCI_FORMAT_MSF;
     if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
         WARN("error reading TracksInfo !\n");
-        return MCIERR_INTERNAL;
-    }
-    
-    CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
+        //CDAUDIO_Close(&wmcda->wcda);
+        //return MCIERR_INTERNAL;
+    }
+    
+    //CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
 
     return 0;
@@ -268 +282 @@
     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
 
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms);
+    TRACE("Entering CDAUDIO_mciClose... (%04X, %08lX, %p) wmcd: %X;\n", wDevID, dwParam, lpParms, wmcda);
 
     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
@@ -287 +301 @@
     DWORD       ret = 0;
 
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("CDAUDIO_mciGetDevCaps: (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
 
     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
@@ -295 +309 @@
 
         switch (lpParms->dwItem) {
-        case MCI_GETDEVCAPS_CAN_RECORD:
-            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_HAS_AUDIO:
-            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_HAS_VIDEO:
-            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_DEVICE_TYPE:
-            lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_USES_FILES:
-            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_COMPOUND_DEVICE:
-            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_CAN_EJECT:
-            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_CAN_PLAY:
-            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
-            ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_GETDEVCAPS_CAN_SAVE:
-            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
-            ret = MCI_RESOURCE_RETURNED;
+        case MCI_GETDEVCAPS_CAN_RECORD: /* 0x00000001L */
+            lpParms->dwReturn = FALSE;
+            break;
+        case MCI_GETDEVCAPS_HAS_AUDIO: /* 0x00000002L */
+            lpParms->dwReturn = TRUE;
+            break;
+        case MCI_GETDEVCAPS_HAS_VIDEO: /* 0x00000003L */
+            lpParms->dwReturn = FALSE;
+            break;
+        case MCI_GETDEVCAPS_DEVICE_TYPE: /* 0x00000004L */
+            lpParms->dwReturn = MCI_DEVTYPE_CD_AUDIO;
+            break;
+        case MCI_GETDEVCAPS_USES_FILES: /* 0x00000005L */
+            lpParms->dwReturn = FALSE;
+            break;
+        case MCI_GETDEVCAPS_COMPOUND_DEVICE: /* 0x00000006L */
+            lpParms->dwReturn = FALSE;
+            break;
+        case MCI_GETDEVCAPS_CAN_EJECT: /* 0x00000007L*/
+            lpParms->dwReturn = TRUE;
+            break;
+        case MCI_GETDEVCAPS_CAN_PLAY: /* 0x00000008L*/
+            lpParms->dwReturn = TRUE;
+            break;
+        case MCI_GETDEVCAPS_CAN_SAVE: /* 0x00000009L */
+            lpParms->dwReturn = FALSE;
             break;
         default:
@@ -341 +346 @@
     TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
     return ret;
+
+#if 0
+    /* This is Wine stuff */
+    if (dwFlags & MCI_GETDEVCAPS_ITEM) {
+        TRACE("MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms->dwItem);
+
+        switch (lpParms->dwItem) {
+        case MCI_GETDEVCAPS_CAN_RECORD: /* 0x00000001L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_HAS_AUDIO: /* 0x00000002L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_HAS_VIDEO: /* 0x00000003L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_DEVICE_TYPE: /* 0x00000004L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_USES_FILES: /* 0x00000005L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_COMPOUND_DEVICE: /* 0x00000006L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_CAN_EJECT: /* 0x00000007L*/
+            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_CAN_PLAY: /* 0x00000008L*/
+            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        case MCI_GETDEVCAPS_CAN_SAVE: /* 0x00000009L */
+            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
+            ret = MCI_RESOURCE_RETURNED;
+            break;
+        default:
+            ERR("Unsupported %lx devCaps item\n", lpParms->dwItem);
+            return MCIERR_UNRECOGNIZED_COMMAND;
+        }
+    } else {
+        TRACE("No GetDevCaps-Item !\n");
+        return MCIERR_UNRECOGNIZED_COMMAND;
+    }
+    TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
+    return ret;
+#endif
 }
 
@@ -353 +412 @@
     char                buffer[16];
 
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciInfo... (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
@@ -361 +420 @@
     TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
     
-    if (dwFlags & MCI_INFO_PRODUCT) {
-        str = "Wine's audio CD";
-    } else if (dwFlags & MCI_INFO_MEDIA_UPC) {
-//      ret = MCIERR_NO_IDENTITY;
+    if (dwFlags & MCI_INFO_PRODUCT) {/* 0x00000100L */
+        str = "Odins audio CD";
+    } else if (dwFlags & MCI_INFO_MEDIA_UPC) {   /* 0x00000400L */
+        //      ret = MCIERR_NO_IDENTITY;
         ret = 0; // No Info about MCIERR_NO_IDENTITY
-    } else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) {
+    } else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) { /* 0x00000800L */
         DWORD   msf, res = 0, dummy;
         int     i;
@@ -377 +436 @@
             msf = CDAUDIO_CalcTime(wmcda, MCI_FORMAT_MSF, wmcda->wcda.lpdwTrackPos[i], &dummy);
             res += (MCI_MSF_MINUTE(msf) << 16) +
-                   (MCI_MSF_SECOND(msf) << 8) +
-                   (MCI_MSF_FRAME(msf));
+                (MCI_MSF_SECOND(msf) << 8) +
+                (MCI_MSF_FRAME(msf));
         }
         if (wmcda->wcda.nTracks <= 2) {
@@ -403 +462 @@
         *lpParms->lpstrReturn = 0;
     }
-    TRACE("=> %s (%ld)\n", lpParms->lpstrReturn, ret);
+    TRACE("CDAUDIO_mciInfo returns => %s (ret=%ld)\n", lpParms->lpstrReturn, ret);
     return ret;
 }
@@ -415 +474 @@
     DWORD               ret = 0;
 
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciStatus (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
@@ -425 +484 @@
                         wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
     }
-    if (dwFlags & MCI_STATUS_ITEM) {
+    if (dwFlags & MCI_STATUS_ITEM) { /* MCI_STATUS_ITEM 0x00000100L */
+        TRACE("item: %lx!\n", lpParms->dwItem);
         switch (lpParms->dwItem) {
-        case MCI_STATUS_CURRENT_TRACK:
+        case MCI_STATUS_CURRENT_TRACK: /* 0x00000008L */
             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) {
                 return CDAUDIO_mciGetError(wmcda);
@@ -434 +494 @@
             TRACE("CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
             break;
-        case MCI_STATUS_LENGTH:
+        case MCI_STATUS_LENGTH: /* 0x00000001L */
             if (wmcda->wcda.nTracks == 0) {
                 if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
@@ -456 +516 @@
             TRACE("LENGTH=%lu !\n", lpParms->dwReturn);
             break;
-        case MCI_STATUS_MODE:
+        case MCI_STATUS_MODE: /* 0x00000004L */
             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) 
                 return CDAUDIO_mciGetError(wmcda);
             lpParms->dwReturn = CDAUDIO_mciMode(wmcda->wcda.cdaMode);
-            if (!lpParms->dwReturn) lpParms->dwReturn = wmcda->mciMode;
+            if (!lpParms->dwReturn) 
+                lpParms->dwReturn = wmcda->mciMode;
             TRACE("MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn);
+#if 0
+            /* What's Wine doing here??? */
             lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn, lpParms->dwReturn);
             ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_STATUS_MEDIA_PRESENT:
+#endif
+            break;
+        case MCI_STATUS_MEDIA_PRESENT: /* 0x00000005L */
             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) 
                 return CDAUDIO_mciGetError(wmcda);
+            lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ? FALSE : TRUE;
+            TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
+#if 0
+            /* What's Wine doing here??? */
             lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ? 
                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
             TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
             ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_STATUS_NUMBER_OF_TRACKS:
+#endif
+            break;
+        case MCI_STATUS_NUMBER_OF_TRACKS: /* 0x00000003L */
             lpParms->dwReturn = CDAUDIO_GetNumberOfTracks(&wmcda->wcda);
             TRACE("MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms->dwReturn);
@@ -479 +548 @@
                 return CDAUDIO_mciGetError(wmcda);
             break;
-        case MCI_STATUS_POSITION:
+        case MCI_STATUS_POSITION: /* 0x00000002L */
             if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) 
                 return CDAUDIO_mciGetError(wmcda);
             lpParms->dwReturn = wmcda->wcda.dwCurFrame;
             if (dwFlags & MCI_STATUS_START) {
-                lpParms->dwReturn = wmcda->wcda.dwFirstFrame;
+                lpParms->dwReturn = wmcda->wcda.dwFirstFrame;
                 TRACE("get MCI_STATUS_START !\n");
             }
@@ -490 +559 @@
                 if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
                     return MCIERR_OUTOFRANGE;
-                lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
-                TRACE("get MCI_TRACK #%lu !\n", lpParms->dwTrack);
-            }
+                if(wmcda->wcda.nCurTrack)
+                    lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
+                //TRACE("get MCI_TRACK #%lu, track position: %lu !\n", lpParms->dwTrack, lpParms->dwReturn);
+            }
             lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, wmcda->dwTimeFormat, lpParms->dwReturn, &ret);
-            TRACE("MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn);
-            break;
-        case MCI_STATUS_READY:
+            TRACE("MCI_STATUS_POSITION=%08lX, track %d !\n", lpParms->dwReturn, lpParms->dwTrack);
+            break;
+        case MCI_STATUS_READY: /* 0x00000007L */
             TRACE("MCI_STATUS_READY !\n");
+            lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
+                                 wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ? FALSE : TRUE;
+            TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
+#if 0
+            /* What's Wine doing here??? */
             lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
                                  wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ?
@@ -503 +578 @@
             TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
             ret = MCI_RESOURCE_RETURNED;
-            break;
-        case MCI_STATUS_TIME_FORMAT:
+#endif
+            break;
+        case MCI_STATUS_TIME_FORMAT: /* 0x00000006L */
+#if 0
+            /* What's Wine doing here??? */
             lpParms->dwReturn = MAKEMCIRESOURCE(wmcda->dwTimeFormat, wmcda->dwTimeFormat);
+            ret = MCI_RESOURCE_RETURNED;
+#endif
+            lpParms->dwReturn = wmcda->dwTimeFormat;
             TRACE("MCI_STATUS_TIME_FORMAT=%08x!\n", LOWORD(lpParms->dwReturn));
-            ret = MCI_RESOURCE_RETURNED;
             break;
         case 4001: /* FIXME: for boggus FullCD */
@@ -539 +619 @@
     DWORD               ret = 0;
     
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciPlay (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (lpParms == NULL) {
@@ -588 +668 @@
     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
     
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciStop (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
@@ -611 +691 @@
     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
     
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciPause (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
@@ -656 +736 @@
     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
     
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciSeek (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     
     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
@@ -671 +751 @@
         at = wmcda->wcda.dwLastFrame;
         break;
-    case MCI_TO:
+    case MCI_TO: /* 0x00000008L */
         TRACE("Seeking to %lu\n", lpParms->dwTo);
         at = lpParms->dwTo;
@@ -714 +794 @@
     WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
     
-    TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
+    TRACE("Entering CDAUDIO_mciSet (%04X, %08lX, %p, %08lX);\n", wDevID, dwFlags, lpParms, wmcda);
     
     if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;;
-    /*
+    
       TRACE("dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
       TRACE("dwAudio=%08lX\n", lpParms->dwAudio);
-    */
+    
     if (dwFlags & MCI_SET_TIME_FORMAT) {
         switch (lpParms->dwTimeFormat) {
-        case MCI_FORMAT_MILLISECONDS:
-            TRACE("MCI_FORMAT_MILLISECONDS !\n");
-            break;
-        case MCI_FORMAT_MSF:
+        case MCI_FORMAT_MILLISECONDS: /* 0 */
+            TRACE("MCI_FORMAT_MILLISECONDS !\n"); 
+            break;
+        case MCI_FORMAT_MSF: /* 2 */
             TRACE("MCI_FORMAT_MSF !\n");
             break;
-        case MCI_FORMAT_TMSF:
+#if 0
+        case MCI_FORMAT_FRAMES:  /* 3 */
+            TRACE("MCI_FORMAT_FRAMES !\n");
+            break;
+        case MCI_FORMAT_SAMPLES: /*  9 */
+            TRACE("MCI_FORMAT_SAMPLES !\n");
+            break;
+#endif
+        case MCI_FORMAT_TMSF: /* 10 */
             TRACE("MCI_FORMAT_TMSF !\n");
             break;
@@ -738 +826 @@
         }
         wmcda->dwTimeFormat = lpParms->dwTimeFormat;
-    }
+    } /* end of if (dwFlags & MCI_SET_TIME_FORMAT) */
+
     if (dwFlags & MCI_SET_DOOR_OPEN) {
         CDAUDIO_mciSetDoor(wDevID, TRUE);
@@ -745 +834 @@
         CDAUDIO_mciSetDoor(wDevID, FALSE);
     }
+
+    if (dwFlags & MCI_SET_ON){
+        if(dwFlags & MCI_SET_AUDIO) {
+            TRACE("MCI_SET_AUDIO -> %x !\n",lpParms->dwAudio);
+            FIXME("FIXME: MCI_SET_ON for cdaudio not implemented (is it necessary?)\n");
+            return 0;
+        }
+    }
+
     if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
-    if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
     if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
     if (dwFlags & MCI_NOTIFY) {
@@ -763 +860 @@
                                       DWORD dwParam1, DWORD dwParam2)
 {
+
     switch(wMsg) {
     case DRV_LOAD:              return 1;
@@ -770 +868 @@
     case DRV_ENABLE:            return 1;       
     case DRV_DISABLE:           return 1;
-    case DRV_QUERYCONFIGURE:    return 1;
-    case DRV_CONFIGURE:         MessageBoxA(0, "Sample Multimedia Driver !", "Wine Driver", MB_OK); return 1;
+    case DRV_QUERYCONFIGURE:    
+        TRACE("Received DRV_QUERYCONFIGURE command [%lu] \n", wMsg);
+        return 0; /* We can't configure */
+    case DRV_CONFIGURE:
+        TRACE("Received DRV_CONFIGURE command [%lu] \n", wMsg);
+        //MessageBoxA(0, "CD audio Driver !", "Odin Driver", MB_OK);
+        return 1;
     case DRV_INSTALL:           return DRVCNF_RESTART;
     case DRV_REMOVE:            return DRVCNF_RESTART;
@@ -809 +912 @@
     /* commands that should report an error */
     case MCI_WINDOW:            
-        TRACE("Unsupported command [%lu]\n", wMsg);
-        break;
+        TRACE("Received command [%lu] (MCI_WINDOW). Why do we get video messages???\n", wMsg);
+        break;
+    case MCI_CONFIGURE:         
+        TRACE("Received Command [%lu] (MCI_CONFIGURE). Why do we get video messages???\n", wMsg);
+        break;
+
+
     case MCI_OPEN:
     case MCI_CLOSE:
@@ -816 +924 @@
         break;
     default:
-        TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
+        TRACE("Sending msg [%lXh] to default driver proc\n", wMsg);
         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
     }