Ignore:
Timestamp:
Dec 2, 2000, 12:37:34 PM (25 years ago)
Author:
sandervl
Message:

CW: Rewrote for OS/2

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/mcicda/mcicda.cpp

    r2473 r4709  
    11/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    22/*
    3  * Sample MCI CDAUDIO Wine Driver for Linux
     3 * MCI CDAUDIO Driver for OS/2
    44 *
    55 * Copyright 1994    Martin Ayotte
    66 * Copyright 1998-99 Eric Pouech
     7 * Copyright 2000    Chris Wohlgemuth
     8 *
     9 * Project Odin Software License can be found in LICENSE.TXT
     10 *
    711 */
    812
    … …  
    1014#include <string.h>
    1115#include "winuser.h"
    12 #include "driver.h"
     16////#include "driver.h"
    1317#include "mmddk.h"
    1418#include "cdrom.h"
    … …  
    1721DEFAULT_DEBUG_CHANNEL(cdaudio)
    1822
    19 typedef struct {
    20     UINT                wDevID;
    21     int                 nUseCount;          /* Incremented for each shared open */
    22     BOOL                fShareable;         /* TRUE if first open was shareable */
    23     WORD                wNotifyDeviceID;    /* MCI device ID with a pending notification */
    24     HANDLE              hCallback;          /* Callback handle for pending notification */
    25     DWORD               dwTimeFormat;
    26     WINE_CDAUDIO        wcda;
    27     int                 mciMode;
    28 } WINE_MCICDAUDIO;
    2923
    3024/*-----------------------------------------------------------------------*/
    … …  
    6862    WINE_MCICDAUDIO*    wmcda = (WINE_MCICDAUDIO*)mciGetDriverData(wDevID);
    6963   
    70     if (wmcda == NULL || wmcda->nUseCount == 0 || wmcda->wcda.unixdev <= 0) {
    71         WARN("Invalid wDevID=%u\n", wDevID);
     64    if (wmcda == NULL || wmcda->nUseCount == 0 /*|| wmcda->wcda.unixdev <= 0*/ ) {
     65        WARN("CDAUDIO_mciGetOpenDrv(UINT wDevID): Invalid wDevID=%u\n", wDevID);
    7266        return 0;
    7367    }
    … …  
    8175{
    8276    switch (wcdaMode) {
    83     case WINE_CDA_DONTKNOW:     return MCI_MODE_STOP;
    84     case WINE_CDA_NOTREADY:     return MCI_MODE_STOP;
     77    case WINE_CDA_DONTKNOW:     return MCI_MODE_STOP;/* 0x20d */
     78    case WINE_CDA_NOTREADY:     return MCI_MODE_STOP;/* 0x20d */
    8579    case WINE_CDA_OPEN:         return MCI_MODE_OPEN;
    8680    case WINE_CDA_PLAY:         return MCI_MODE_PLAY;
    87     case WINE_CDA_STOP:         return MCI_MODE_STOP;
     81    case WINE_CDA_STOP:         return MCI_MODE_STOP;/* 0x20d */
    8882    case WINE_CDA_PAUSE:        return MCI_MODE_PAUSE;
    8983    default:
    … …  
    215209    MCI_SEEK_PARMS      seekParms;
    216210
    217     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpOpenParms);
     211    dprintf(("CDAUDIO_mciOpen: (wDevID: %04X, dwFlags: %08lX, %p);\n", wDevID, dwFlags, lpOpenParms));
     212   
    218213   
    219214    if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
    … …  
    239234            return MCIERR_NO_ELEMENT_ALLOWED;
    240235        }
    241         WARN("MCI_OPEN_ELEMENT %s ignored\n",lpOpenParms->lpstrElementName);
     236        /* Cdplayer.exe puts the driveletter into lpOpenParms->lpstrElementName */
     237        TRACE("CDAUDIO_mciOpen(): MCI_OPEN_ELEMENT: %s\n",lpOpenParms->lpstrElementName);
     238
     239        if(strlen(lpOpenParms->lpstrElementName)==2)
     240            strcpy(wmcda->wcda.chrDrive,lpOpenParms->lpstrElementName);/* Save */
    242241        /*return MCIERR_NO_ELEMENT_ALLOWED;
    243242          bon 19991106 allows cdplayer.exe to run*/
    244243    }
     244    else if (dwFlags & MCI_OPEN_TYPE) {/*MCI_OPEN_TYPE  0x00002000L*/
     245        TRACE("CDAUDIO_mciOpen(): MCI_OPEN_TYPE: %s\n",lpOpenParms->lpstrDeviceType);
     246        wmcda->wcda.chrDrive[0]=0; /* Mark that we don't have a drive */
     247        if(lpOpenParms->lpstrDeviceType)
     248            strncpy(wmcda->wcda.chrDeviceType,lpOpenParms->lpstrDeviceType,sizeof(wmcda->wcda.chrDeviceType)-1);
     249        else
     250            wmcda->wcda.chrDeviceType[0]=0;
     251    }
    245252
    246253    wmcda->wNotifyDeviceID = dwDeviceID;
    247     if (CDAUDIO_Open(&wmcda->wcda) == -1) {
     254
     255
     256    if (!CDAUDIO_Open(&wmcda->wcda)) {
     257#if 0
     258        /* We're always successful because we open the driver not the disk */
    248259        --wmcda->nUseCount;
    249260        return MCIERR_HARDWARE;
    250     }
     261#endif
     262    }
     263
    251264    wmcda->mciMode = MCI_MODE_STOP;
    252265    wmcda->dwTimeFormat = MCI_FORMAT_MSF;
    253266    if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
    254267        WARN("error reading TracksInfo !\n");
    255         return MCIERR_INTERNAL;
    256     }
    257    
    258     CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
     268        //CDAUDIO_Close(&wmcda->wcda);
     269        //return MCIERR_INTERNAL;
     270    }
     271   
     272    //CDAUDIO_mciSeek(wDevID, MCI_SEEK_TO_START, &seekParms);
    259273
    260274    return 0;
    … …  
    268282    WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
    269283
    270     TRACE("(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms);
     284    TRACE("Entering CDAUDIO_mciClose... (%04X, %08lX, %p) wmcd: %X;\n", wDevID, dwParam, lpParms, wmcda);
    271285
    272286    if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
    … …  
    287301    DWORD       ret = 0;
    288302
    289     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     303    TRACE("CDAUDIO_mciGetDevCaps: (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    290304
    291305    if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
    … …  
    295309
    296310        switch (lpParms->dwItem) {
    297         case MCI_GETDEVCAPS_CAN_RECORD:
    298             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
    299             ret = MCI_RESOURCE_RETURNED;
    300             break;
    301         case MCI_GETDEVCAPS_HAS_AUDIO:
    302             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
    303             ret = MCI_RESOURCE_RETURNED;
    304             break;
    305         case MCI_GETDEVCAPS_HAS_VIDEO:
    306             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
    307             ret = MCI_RESOURCE_RETURNED;
    308             break;
    309         case MCI_GETDEVCAPS_DEVICE_TYPE:
    310             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
    311             ret = MCI_RESOURCE_RETURNED;
    312             break;
    313         case MCI_GETDEVCAPS_USES_FILES:
    314             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
    315             ret = MCI_RESOURCE_RETURNED;
    316             break;
    317         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
    318             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
    319             ret = MCI_RESOURCE_RETURNED;
    320             break;
    321         case MCI_GETDEVCAPS_CAN_EJECT:
    322             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
    323             ret = MCI_RESOURCE_RETURNED;
    324             break;
    325         case MCI_GETDEVCAPS_CAN_PLAY:
    326             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
    327             ret = MCI_RESOURCE_RETURNED;
    328             break;
    329         case MCI_GETDEVCAPS_CAN_SAVE:
    330             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
    331             ret = MCI_RESOURCE_RETURNED;
     311        case MCI_GETDEVCAPS_CAN_RECORD: /* 0x00000001L */
     312            lpParms->dwReturn = FALSE;
     313            break;
     314        case MCI_GETDEVCAPS_HAS_AUDIO: /* 0x00000002L */
     315            lpParms->dwReturn = TRUE;
     316            break;
     317        case MCI_GETDEVCAPS_HAS_VIDEO: /* 0x00000003L */
     318            lpParms->dwReturn = FALSE;
     319            break;
     320        case MCI_GETDEVCAPS_DEVICE_TYPE: /* 0x00000004L */
     321            lpParms->dwReturn = MCI_DEVTYPE_CD_AUDIO;
     322            break;
     323        case MCI_GETDEVCAPS_USES_FILES: /* 0x00000005L */
     324            lpParms->dwReturn = FALSE;
     325            break;
     326        case MCI_GETDEVCAPS_COMPOUND_DEVICE: /* 0x00000006L */
     327            lpParms->dwReturn = FALSE;
     328            break;
     329        case MCI_GETDEVCAPS_CAN_EJECT: /* 0x00000007L*/
     330            lpParms->dwReturn = TRUE;
     331            break;
     332        case MCI_GETDEVCAPS_CAN_PLAY: /* 0x00000008L*/
     333            lpParms->dwReturn = TRUE;
     334            break;
     335        case MCI_GETDEVCAPS_CAN_SAVE: /* 0x00000009L */
     336            lpParms->dwReturn = FALSE;
    332337            break;
    333338        default:
    … …  
    341346    TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
    342347    return ret;
     348
     349#if 0
     350    /* This is Wine stuff */
     351    if (dwFlags & MCI_GETDEVCAPS_ITEM) {
     352        TRACE("MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n", lpParms->dwItem);
     353
     354        switch (lpParms->dwItem) {
     355        case MCI_GETDEVCAPS_CAN_RECORD: /* 0x00000001L */
     356            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
     357            ret = MCI_RESOURCE_RETURNED;
     358            break;
     359        case MCI_GETDEVCAPS_HAS_AUDIO: /* 0x00000002L */
     360            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
     361            ret = MCI_RESOURCE_RETURNED;
     362            break;
     363        case MCI_GETDEVCAPS_HAS_VIDEO: /* 0x00000003L */
     364            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
     365            ret = MCI_RESOURCE_RETURNED;
     366            break;
     367        case MCI_GETDEVCAPS_DEVICE_TYPE: /* 0x00000004L */
     368            lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_CD_AUDIO, MCI_DEVTYPE_CD_AUDIO);
     369            ret = MCI_RESOURCE_RETURNED;
     370            break;
     371        case MCI_GETDEVCAPS_USES_FILES: /* 0x00000005L */
     372            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
     373            ret = MCI_RESOURCE_RETURNED;
     374            break;
     375        case MCI_GETDEVCAPS_COMPOUND_DEVICE: /* 0x00000006L */
     376            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
     377            ret = MCI_RESOURCE_RETURNED;
     378            break;
     379        case MCI_GETDEVCAPS_CAN_EJECT: /* 0x00000007L*/
     380            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
     381            ret = MCI_RESOURCE_RETURNED;
     382            break;
     383        case MCI_GETDEVCAPS_CAN_PLAY: /* 0x00000008L*/
     384            lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
     385            ret = MCI_RESOURCE_RETURNED;
     386            break;
     387        case MCI_GETDEVCAPS_CAN_SAVE: /* 0x00000009L */
     388            lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
     389            ret = MCI_RESOURCE_RETURNED;
     390            break;
     391        default:
     392            ERR("Unsupported %lx devCaps item\n", lpParms->dwItem);
     393            return MCIERR_UNRECOGNIZED_COMMAND;
     394        }
     395    } else {
     396        TRACE("No GetDevCaps-Item !\n");
     397        return MCIERR_UNRECOGNIZED_COMMAND;
     398    }
     399    TRACE("lpParms->dwReturn=%08lX;\n", lpParms->dwReturn);
     400    return ret;
     401#endif
    343402}
    344403
    … …  
    353412    char                buffer[16];
    354413
    355     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     414    TRACE("Entering CDAUDIO_mciInfo... (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    356415   
    357416    if (lpParms == NULL || lpParms->lpstrReturn == NULL)
    … …  
    361420    TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
    362421   
    363     if (dwFlags & MCI_INFO_PRODUCT) {
    364         str = "Wine's audio CD";
    365     } else if (dwFlags & MCI_INFO_MEDIA_UPC) {
    366 //      ret = MCIERR_NO_IDENTITY;
     422    if (dwFlags & MCI_INFO_PRODUCT) {/* 0x00000100L */
     423        str = "Odins audio CD";
     424    } else if (dwFlags & MCI_INFO_MEDIA_UPC) {   /* 0x00000400L */
     425        //      ret = MCIERR_NO_IDENTITY;
    367426        ret = 0; // No Info about MCIERR_NO_IDENTITY
    368     } else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) {
     427    } else if (dwFlags & MCI_INFO_MEDIA_IDENTITY) { /* 0x00000800L */
    369428        DWORD   msf, res = 0, dummy;
    370429        int     i;
    … …  
    377436            msf = CDAUDIO_CalcTime(wmcda, MCI_FORMAT_MSF, wmcda->wcda.lpdwTrackPos[i], &dummy);
    378437            res += (MCI_MSF_MINUTE(msf) << 16) +
    379                    (MCI_MSF_SECOND(msf) << 8) +
    380                    (MCI_MSF_FRAME(msf));
     438                (MCI_MSF_SECOND(msf) << 8) +
     439                (MCI_MSF_FRAME(msf));
    381440        }
    382441        if (wmcda->wcda.nTracks <= 2) {
    … …  
    403462        *lpParms->lpstrReturn = 0;
    404463    }
    405     TRACE("=> %s (%ld)\n", lpParms->lpstrReturn, ret);
     464    TRACE("CDAUDIO_mciInfo returns => %s (ret=%ld)\n", lpParms->lpstrReturn, ret);
    406465    return ret;
    407466}
    … …  
    415474    DWORD               ret = 0;
    416475
    417     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     476    TRACE("Entering CDAUDIO_mciStatus (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    418477   
    419478    if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
    … …  
    425484                        wmcda->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
    426485    }
    427     if (dwFlags & MCI_STATUS_ITEM) {
     486    if (dwFlags & MCI_STATUS_ITEM) { /* MCI_STATUS_ITEM 0x00000100L */
     487        TRACE("item: %lx!\n", lpParms->dwItem);
    428488        switch (lpParms->dwItem) {
    429         case MCI_STATUS_CURRENT_TRACK:
     489        case MCI_STATUS_CURRENT_TRACK: /* 0x00000008L */
    430490            if (!CDAUDIO_GetCDStatus(&wmcda->wcda)) {
    431491                return CDAUDIO_mciGetError(wmcda);
    … …  
    434494            TRACE("CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
    435495            break;
    436         case MCI_STATUS_LENGTH:
     496        case MCI_STATUS_LENGTH: /* 0x00000001L */
    437497            if (wmcda->wcda.nTracks == 0) {
    438498                if (!CDAUDIO_GetTracksInfo(&wmcda->wcda)) {
    … …  
    456516            TRACE("LENGTH=%lu !\n", lpParms->dwReturn);
    457517            break;
    458         case MCI_STATUS_MODE:
     518        case MCI_STATUS_MODE: /* 0x00000004L */
    459519            if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
    460520                return CDAUDIO_mciGetError(wmcda);
    461521            lpParms->dwReturn = CDAUDIO_mciMode(wmcda->wcda.cdaMode);
    462             if (!lpParms->dwReturn) lpParms->dwReturn = wmcda->mciMode;
     522            if (!lpParms->dwReturn)
     523                lpParms->dwReturn = wmcda->mciMode;
    463524            TRACE("MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn);
     525#if 0
     526            /* What's Wine doing here??? */
    464527            lpParms->dwReturn = MAKEMCIRESOURCE(lpParms->dwReturn, lpParms->dwReturn);
    465528            ret = MCI_RESOURCE_RETURNED;
    466             break;
    467         case MCI_STATUS_MEDIA_PRESENT:
     529#endif
     530            break;
     531        case MCI_STATUS_MEDIA_PRESENT: /* 0x00000005L */
    468532            if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
    469533                return CDAUDIO_mciGetError(wmcda);
     534            lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ? FALSE : TRUE;
     535            TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
     536#if 0
     537            /* What's Wine doing here??? */
    470538            lpParms->dwReturn = (wmcda->wcda.nTracks == 0) ?
    471539                MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
    472540            TRACE("MCI_STATUS_MEDIA_PRESENT =%c!\n", LOWORD(lpParms->dwReturn) ? 'Y' : 'N');
    473541            ret = MCI_RESOURCE_RETURNED;
    474             break;
    475         case MCI_STATUS_NUMBER_OF_TRACKS:
     542#endif
     543            break;
     544        case MCI_STATUS_NUMBER_OF_TRACKS: /* 0x00000003L */
    476545            lpParms->dwReturn = CDAUDIO_GetNumberOfTracks(&wmcda->wcda);
    477546            TRACE("MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n", lpParms->dwReturn);
    … …  
    479548                return CDAUDIO_mciGetError(wmcda);
    480549            break;
    481         case MCI_STATUS_POSITION:
     550        case MCI_STATUS_POSITION: /* 0x00000002L */
    482551            if (!CDAUDIO_GetCDStatus(&wmcda->wcda))
    483552                return CDAUDIO_mciGetError(wmcda);
    484553            lpParms->dwReturn = wmcda->wcda.dwCurFrame;
    485554            if (dwFlags & MCI_STATUS_START) {
    486                 lpParms->dwReturn = wmcda->wcda.dwFirstFrame;
     555                lpParms->dwReturn = wmcda->wcda.dwFirstFrame;
    487556                TRACE("get MCI_STATUS_START !\n");
    488557            }
    … …  
    490559                if (lpParms->dwTrack > wmcda->wcda.nTracks || lpParms->dwTrack == 0)
    491560                    return MCIERR_OUTOFRANGE;
    492                 lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
    493                 TRACE("get MCI_TRACK #%lu !\n", lpParms->dwTrack);
    494             }
     561                if(wmcda->wcda.nCurTrack)
     562                    lpParms->dwReturn = wmcda->wcda.lpdwTrackPos[lpParms->dwTrack - 1];
     563                //TRACE("get MCI_TRACK #%lu, track position: %lu !\n", lpParms->dwTrack, lpParms->dwReturn);
     564            }
    495565            lpParms->dwReturn = CDAUDIO_CalcTime(wmcda, wmcda->dwTimeFormat, lpParms->dwReturn, &ret);
    496             TRACE("MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn);
    497             break;
    498         case MCI_STATUS_READY:
     566            TRACE("MCI_STATUS_POSITION=%08lX, track %d !\n", lpParms->dwReturn, lpParms->dwTrack);
     567            break;
     568        case MCI_STATUS_READY: /* 0x00000007L */
    499569            TRACE("MCI_STATUS_READY !\n");
     570            lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
     571                                 wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ? FALSE : TRUE;
     572            TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
     573#if 0
     574            /* What's Wine doing here??? */
    500575            lpParms->dwReturn = (wmcda->wcda.cdaMode == WINE_CDA_DONTKNOW ||
    501576                                 wmcda->wcda.cdaMode == WINE_CDA_NOTREADY) ?
    … …  
    503578            TRACE("MCI_STATUS_READY=%u!\n", LOWORD(lpParms->dwReturn));
    504579            ret = MCI_RESOURCE_RETURNED;
    505             break;
    506         case MCI_STATUS_TIME_FORMAT:
     580#endif
     581            break;
     582        case MCI_STATUS_TIME_FORMAT: /* 0x00000006L */
     583#if 0
     584            /* What's Wine doing here??? */
    507585            lpParms->dwReturn = MAKEMCIRESOURCE(wmcda->dwTimeFormat, wmcda->dwTimeFormat);
     586            ret = MCI_RESOURCE_RETURNED;
     587#endif
     588            lpParms->dwReturn = wmcda->dwTimeFormat;
    508589            TRACE("MCI_STATUS_TIME_FORMAT=%08x!\n", LOWORD(lpParms->dwReturn));
    509             ret = MCI_RESOURCE_RETURNED;
    510590            break;
    511591        case 4001: /* FIXME: for boggus FullCD */
    … …  
    539619    DWORD               ret = 0;
    540620   
    541     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     621    TRACE("Entering CDAUDIO_mciPlay (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    542622   
    543623    if (lpParms == NULL) {
    … …  
    588668    WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
    589669   
    590     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     670    TRACE("Entering CDAUDIO_mciStop (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    591671   
    592672    if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
    … …  
    611691    WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
    612692   
    613     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     693    TRACE("Entering CDAUDIO_mciPause (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    614694   
    615695    if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
    … …  
    656736    WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
    657737   
    658     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     738    TRACE("Entering CDAUDIO_mciSeek (%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
    659739   
    660740    if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
    … …  
    671751        at = wmcda->wcda.dwLastFrame;
    672752        break;
    673     case MCI_TO:
     753    case MCI_TO: /* 0x00000008L */
    674754        TRACE("Seeking to %lu\n", lpParms->dwTo);
    675755        at = lpParms->dwTo;
    … …  
    714794    WINE_MCICDAUDIO*    wmcda = CDAUDIO_mciGetOpenDrv(wDevID);
    715795   
    716     TRACE("(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
     796    TRACE("Entering CDAUDIO_mciSet (%04X, %08lX, %p, %08lX);\n", wDevID, dwFlags, lpParms, wmcda);
    717797   
    718798    if (wmcda == NULL)  return MCIERR_INVALID_DEVICE_ID;
    719799    if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;;
    720     /*
     800   
    721801      TRACE("dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
    722802      TRACE("dwAudio=%08lX\n", lpParms->dwAudio);
    723     */
     803   
    724804    if (dwFlags & MCI_SET_TIME_FORMAT) {
    725805        switch (lpParms->dwTimeFormat) {
    726         case MCI_FORMAT_MILLISECONDS:
    727             TRACE("MCI_FORMAT_MILLISECONDS !\n");
    728             break;
    729         case MCI_FORMAT_MSF:
     806        case MCI_FORMAT_MILLISECONDS: /* 0 */
     807            TRACE("MCI_FORMAT_MILLISECONDS !\n"); 
     808            break;
     809        case MCI_FORMAT_MSF: /* 2 */
    730810            TRACE("MCI_FORMAT_MSF !\n");
    731811            break;
    732         case MCI_FORMAT_TMSF:
     812#if 0
     813        case MCI_FORMAT_FRAMES:  /* 3 */
     814            TRACE("MCI_FORMAT_FRAMES !\n");
     815            break;
     816        case MCI_FORMAT_SAMPLES: /*  9 */
     817            TRACE("MCI_FORMAT_SAMPLES !\n");
     818            break;
     819#endif
     820        case MCI_FORMAT_TMSF: /* 10 */
    733821            TRACE("MCI_FORMAT_TMSF !\n");
    734822            break;
    … …  
    738826        }
    739827        wmcda->dwTimeFormat = lpParms->dwTimeFormat;
    740     }
     828    } /* end of if (dwFlags & MCI_SET_TIME_FORMAT) */
     829
    741830    if (dwFlags & MCI_SET_DOOR_OPEN) {
    742831        CDAUDIO_mciSetDoor(wDevID, TRUE);
    … …  
    745834        CDAUDIO_mciSetDoor(wDevID, FALSE);
    746835    }
     836
     837    if (dwFlags & MCI_SET_ON){
     838        if(dwFlags & MCI_SET_AUDIO) {
     839            TRACE("MCI_SET_AUDIO -> %x !\n",lpParms->dwAudio);
     840            FIXME("FIXME: MCI_SET_ON for cdaudio not implemented (is it necessary?)\n");
     841            return 0;
     842        }
     843    }
     844
    747845    if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
    748     if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
    749846    if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
    750847    if (dwFlags & MCI_NOTIFY) {
    … …  
    763860                                      DWORD dwParam1, DWORD dwParam2)
    764861{
     862
    765863    switch(wMsg) {
    766864    case DRV_LOAD:              return 1;
    … …  
    770868    case DRV_ENABLE:            return 1;       
    771869    case DRV_DISABLE:           return 1;
    772     case DRV_QUERYCONFIGURE:    return 1;
    773     case DRV_CONFIGURE:         MessageBoxA(0, "Sample Multimedia Driver !", "Wine Driver", MB_OK); return 1;
     870    case DRV_QUERYCONFIGURE:   
     871        TRACE("Received DRV_QUERYCONFIGURE command [%lu] \n", wMsg);
     872        return 0; /* We can't configure */
     873    case DRV_CONFIGURE:
     874        TRACE("Received DRV_CONFIGURE command [%lu] \n", wMsg);
     875        //MessageBoxA(0, "CD audio Driver !", "Odin Driver", MB_OK);
     876        return 1;
    774877    case DRV_INSTALL:           return DRVCNF_RESTART;
    775878    case DRV_REMOVE:            return DRVCNF_RESTART;
    … …  
    809912    /* commands that should report an error */
    810913    case MCI_WINDOW:           
    811         TRACE("Unsupported command [%lu]\n", wMsg);
    812         break;
     914        TRACE("Received command [%lu] (MCI_WINDOW). Why do we get video messages???\n", wMsg);
     915        break;
     916    case MCI_CONFIGURE:         
     917        TRACE("Received Command [%lu] (MCI_CONFIGURE). Why do we get video messages???\n", wMsg);
     918        break;
     919
     920
    813921    case MCI_OPEN:
    814922    case MCI_CLOSE:
    … …  
    816924        break;
    817925    default:
    818         TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
     926        TRACE("Sending msg [%lXh] to default driver proc\n", wMsg);
    819927        return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
    820928    }
Note: See TracChangeset for help on using the changeset viewer.