Changeset 8472 for trunk/src


Ignore:
Timestamp:
May 22, 2002, 10:19:19 PM (23 years ago)
Author:
sandervl
Message:

started with mixer api rewrite

Location:
trunk/src/winmm
Files:
3 added
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/winmm/initwinmm.cpp

    r7674 r8472  
    1 /* $Id: initwinmm.cpp,v 1.6 2001-12-23 09:43:12 sandervl Exp $
     1/* $Id: initwinmm.cpp,v 1.7 2002-05-22 20:19:11 sandervl Exp $
    22 *
    33 * WINMM DLL entry point
     
    4949#include "initwinmm.h"
    5050#include <custombuild.h>
     51#include "mixer.h"
    5152
    5253#define DBG_LOCALLOG    DBG_initterm
     
    169170            RegCloseKey(hKey);
    170171        }
     172        mixerInit();
    171173        return TRUE;
    172174   }
     
    181183        IRTMidiShutdown;  /* JT: Shutdown RT Midi subsystem, if running. */
    182184
     185        mixerExit();
    183186        if(MMPMLibraryHandle) DosFreeModule(MMPMLibraryHandle);
    184187        return TRUE;
  • trunk/src/winmm/mixer.cpp

    r8470 r8472  
    1 /* $Id: mixer.cpp,v 1.11 2002-05-22 15:50:25 sandervl Exp $ */
     1/* $Id: mixer.cpp,v 1.12 2002-05-22 20:19:11 sandervl Exp $ */
    22
    33/*
    4  * Mixer stubs
     4 * Mixer functions
    55 *
    6  * Copyright 1998 Joel Troster
     6 * Copyright 2002 Sander van Leeuwen (sandervl@xs4all.nl)
    77 *
    8  * TODO: This is just a hack to fool apps into thinking a mixer exists
    9  *       Must be redesigned
    10  *
    11  * Based on Wine code (dlls\winmm\wineoss\mixer.c)
    12  * Copyright    1997 Marcus Meissner
    13  *              1999 Eric Pouech
    14  *
    15  *
    168 * Project Odin Software License can be found in LICENSE.TXT
    179 *
     
    3325#include "waveoutdart.h"
    3426#include "winmm.h"
     27#include "initwinmm.h"
     28#include "mixer.h"
     29#include "mixeros2.h"
    3530
    3631#define DBG_LOCALLOG    DBG_mixer
     
    3833
    3934
    40 #define WINMM_MIXERSTRING_A     "OS/2 WINMM Mixer"
    41 #define WINMM_MIXERSTRING_W     (LPWSTR)L"OS/2 WINMM Mixer"
    42 
    43 #define WINMM_SHORTNAME_WAVEOUT_A       "Wave Out"
    44 #define WINMM_SHORTNAME_WAVEOUT_W       (LPWSTR)L"Wave Out"
    45 #define WINMM_SHORTNAME_LINEOUT_A       "Line Out"
    46 #define WINMM_SHORTNAME_LINEOUT_W       (LPWSTR)L"Line Out"
    47 
    48 #define SOUND_MIXER_LINEOUT     0
    49 #define SOUND_MIXER_WAVEOUT     1
    50 #define SOUND_MIXER_MAXID       2
    51 
    52 DWORD MIX_Volume[SOUND_MIXER_MAXID] = { 0x80008000, 0x80008000};
    53 DWORD MIX_Mute[SOUND_MIXER_MAXID]   = { 0, 0};
    54 
    55 //
    56 // All Stubs
    57 //
    58 
    59 /**************************************************************************
    60  *                              MIX_SplitControlID              [internal]
    61  */
    62 static BOOL MIX_SplitControlID(DWORD controlID, LPDWORD lineID, LPDWORD controlType)
    63 {
    64     *lineID = controlID / 2;
    65     *controlType = (controlID & 1) ?
    66         MIXERCONTROL_CONTROLTYPE_MUTE : MIXERCONTROL_CONTROLTYPE_VOLUME;
    67 
    68     return *lineID < SOUND_MIXER_MAXID;
    69 }
    70 /**************************************************************************
    71  *                              MIX_MakeControlID               [internal]
    72  */
    73 static DWORD MIX_MakeControlID(DWORD lineID, DWORD controlType)
    74 {
    75     switch (controlType) {
    76     case MIXERCONTROL_CONTROLTYPE_VOLUME:
    77         return 2 * lineID + 0;
    78     case MIXERCONTROL_CONTROLTYPE_MUTE:
    79         return 2 * lineID + 1;
    80     }
    81     dprintf(("MIX_MakeControlID: Internal error"));
    82     return 0x00FADE00;
    83 }
    84 /**************************************************************************
    85  *                              MIX_DoGetLineControls           [internal]
    86  */
    87 static void MIX_DoGetLineControls(LPMIXERCONTROLA mc, DWORD lineID, DWORD dwType)
    88 {
    89     mc->cbStruct = sizeof(MIXERCONTROLA);
    90    
    91     switch (dwType) {
    92     case MIXERCONTROL_CONTROLTYPE_VOLUME:
    93         mc->dwControlID = MIX_MakeControlID(lineID, dwType);
    94         mc->dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
    95         mc->fdwControl = 0;
    96         mc->cMultipleItems = 0;
    97         lstrcpynA(mc->szShortName, "Vol", MIXER_SHORT_NAME_CHARS);
    98         lstrcpynA(mc->szName, "Volume", MIXER_LONG_NAME_CHARS);
    99         memset(&mc->Bounds, 0, sizeof(mc->Bounds));
    100         mc->Bounds.s1.dwMinimum = 0;
    101         mc->Bounds.s1.dwMaximum = 65535;
    102         memset(&mc->Metrics, 0, sizeof(mc->Metrics));
    103         break;
    104     case MIXERCONTROL_CONTROLTYPE_MUTE:
    105         mc->dwControlID = MIX_MakeControlID(lineID, dwType);
    106         mc->dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
    107         mc->fdwControl = 0;
    108         mc->cMultipleItems = 0;
    109         lstrcpynA(mc->szShortName, "Mute", MIXER_SHORT_NAME_CHARS);
    110         lstrcpynA(mc->szName, "Mute", MIXER_LONG_NAME_CHARS);
    111         memset(&mc->Bounds, 0, sizeof(mc->Bounds));
    112         memset(&mc->Metrics, 0, sizeof(mc->Metrics));
    113         break;
    114     default:
    115         dprintf(("MIX_DoGetLineControls: Internal error: unknown type: %08lx\n", dwType));
    116     }
    117 }
     35MIXERLINEA    mixerDest[MAX_MIXER_DESTINATIONS] = {0};
     36MIXERLINEA    mixerSource[MAX_MIXER_SOURCES]    = {0};
     37MIXERCONTROLA mixerControls[MAX_MIXER_CONTROLS] = {0};
     38
    11839/******************************************************************************/
    11940/******************************************************************************/
     
    12748    switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
    12849    case MIXER_GETCONTROLDETAILSF_VALUE:
    129         if(MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
    130             switch (controlType)
    131             {
    132             case MIXERCONTROL_CONTROLTYPE_VOLUME:
    133                 {
    134                     LPMIXERCONTROLDETAILS_UNSIGNED      mcdu;
    135                     int                                 val;
    136 
    137                     /* return value is 00RL (4 bytes)... */
    138                     val = MIX_Volume[lineID];
    139            
    140                     switch (lpmcd->cChannels) {
    141                     case 1:
    142                         /* mono... so R = L */
    143                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
    144                         mcdu->dwValue = LOWORD(val);
    145                         break;
    146                     case 2:
    147                         /* stereo, left is paDetails[0] */
    148                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
    149                         mcdu->dwValue = LOWORD(val);
    150                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
    151                         mcdu->dwValue = HIWORD(val);
    152                         break;
    153                     default:
    154                         dprintf(("Unknown cChannels (%ld)\n", lpmcd->cChannels));
    155                         return MMSYSERR_INVALPARAM;
    156                     }
    157                 }
    158                 break;
    159             case MIXERCONTROL_CONTROLTYPE_MUTE:
    160                 {
    161                     LPMIXERCONTROLDETAILS_BOOLEAN       mcdb;
    162            
    163                     /* we mute both channels at the same time */
    164                     mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
    165                     mcdb->fValue = MIX_Mute[lineID];
    166                 }
    167                 break;
    168             }
    169             ret = MMSYSERR_NOERROR;
    170         } else {
    171             ret = MMSYSERR_INVALPARAM;
    172         }
    173         break;
     50        break;
    17451    case MIXER_GETCONTROLDETAILSF_LISTTEXT:
    175         dprintf(("mixerGetControlDetailsA: NIY\n"));
    176         break;
     52        dprintf(("mixerGetControlDetailsA: NIY\n"));
     53            break;
    17754    default:
    178         dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
     55            dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
     56        break;
    17957    }
    18058    return ret;
     
    19977    switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) {
    20078    case MIXER_GETCONTROLDETAILSF_VALUE:
    201         if (MIX_SplitControlID(lpmcd->dwControlID, &lineID, &controlType)) {
    202             switch (controlType) {
    203             case MIXERCONTROL_CONTROLTYPE_VOLUME:
    204                 {
    205                     LPMIXERCONTROLDETAILS_UNSIGNED      mcdu;
    206                    
    207                     /* val should contain 00RL */
    208                     switch (lpmcd->cChannels) {
    209                     case 1:
    210                         /* mono... so R = L */
    211                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)lpmcd->paDetails;
    212                         val = mcdu->dwValue;
    213                         break;
    214                     case 2:
    215                         /* stereo, left is paDetails[0] */
    216                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 0 * lpmcd->cbDetails);
    217                         val = mcdu->dwValue;
    218                         mcdu = (LPMIXERCONTROLDETAILS_UNSIGNED)((char*)lpmcd->paDetails + 1 * lpmcd->cbDetails);
    219                         val += (mcdu->dwValue) << 16;
    220                         break;
    221                     default:
    222                         dprintf(("Unknown cChannels (%ld)\n", lpmcd->cChannels));
    223                         return MMSYSERR_INVALPARAM;
    224                     }
    225                    
    226                     MIX_Volume[lineID] = val;
    227                 }
    228                 ret = MMSYSERR_NOERROR;
    229                 break;
    230             case MIXERCONTROL_CONTROLTYPE_MUTE:
    231                 {
    232                     LPMIXERCONTROLDETAILS_BOOLEAN       mcdb;
    233                    
    234                     mcdb = (LPMIXERCONTROLDETAILS_BOOLEAN)lpmcd->paDetails;
    235                     MIX_Mute[lineID] = mcdb->fValue;
    236                 }
    237                 ret = MMSYSERR_NOERROR;
    238                 break;
    239             }
    240         }
    241         break;
     79        break;
    24280    case MIXER_GETCONTROLDETAILSF_LISTTEXT:
    243         dprintf(("mixerSetControlDetails: NIY\n"));
    244         break;
     81        dprintf(("mixerSetControlDetails: NIY\n"));
     82        break;
    24583    default:
    246         dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
     84            dprintf(("Unknown flag (%08lx)\n", fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK));
     85        break;
    24786    }
    24887    return MMSYSERR_NOTSUPPORTED;
     
    267106        }
    268107        else {
    269                 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
    270                 MIX_DoGetLineControls(&lpMlc->pamxctrl[1], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
    271108            }
    272109            break;
    273110    case MIXER_GETLINECONTROLSF_ONEBYID:
    274             if (MIX_SplitControlID(lpMlc->u.dwControlID, &lineID, &controlType))
    275                 MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lineID, controlType);
    276             else
    277                 dwRet = MMSYSERR_INVALPARAM;
    278111            break;
    279112    case MIXER_GETLINECONTROLSF_ONEBYTYPE:
    280113            switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
    281114            case MIXERCONTROL_CT_CLASS_FADER:
    282             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
    283115                break;
    284116            case MIXERCONTROL_CT_CLASS_SWITCH:
    285             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
    286117                break;
    287118            default:
     
    302133    dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
    303134    return MIXERR_INVALLINE;
    304 }
    305 /******************************************************************************/
    306 /******************************************************************************/
    307 MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
    308 {
    309     if(DartWaveOut::getNumDevices() == 0) {
    310         memset(pmxcaps, 0, sizeof(*pmxcaps));
    311         return MMSYSERR_NODRIVER;
    312     }
    313 
    314     // we have to fill in this thing
    315     pmxcaps->wMid = 0;                  /* manufacturer ID */
    316     pmxcaps->wPid = 0;                  /* product ID */
    317     pmxcaps->vDriverVersion = 0x0001;        /* version of the driver */
    318     strcpy( pmxcaps->szPname, WINMM_MIXERSTRING_A); /* product name */
    319 
    320     pmxcaps->fdwSupport = 0;
    321     pmxcaps->cDestinations = 1;
    322 
    323     return MMSYSERR_NOERROR;
    324 }
    325 /******************************************************************************/
    326 /******************************************************************************/
    327 MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
    328 {
    329     if(DartWaveOut::getNumDevices() == 0) {
    330         memset(pmxcaps, 0, sizeof(*pmxcaps));
    331         return MMSYSERR_NODRIVER;
    332     }
    333 
    334     // we have to fill in this thing
    335     pmxcaps->wMid = 0;                  /* manufacturer ID */
    336     pmxcaps->wPid = 0;                  /* product ID */
    337     pmxcaps->vDriverVersion = 0x0001;        /* version of the driver */
    338     lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
    339 
    340     pmxcaps->fdwSupport = 0;
    341     pmxcaps->cDestinations = 1;
    342 
    343     return MMSYSERR_NOERROR;
    344 }
    345 /******************************************************************************/
    346 /******************************************************************************/
    347 MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
    348 {
    349     DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
    350 
    351     if(pMixInfo && puMxId) {
    352         *puMxId = pMixInfo->uDeviceID;
    353     }
    354     else *puMxId = 0;
    355     return MMSYSERR_NOERROR;
    356135}
    357136/******************************************************************************/
     
    373152    {
    374153    case MIXER_GETLINEINFOF_DESTINATION:
    375         /* FIXME: Linux doesn't seem to support multiple outputs?
    376          * So we have only one output type: Speaker.
    377          */
    378         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
    379         lpMl->dwSource = 0xFFFFFFFF;
    380         lpMl->dwLineID = SOUND_MIXER_LINEOUT;
    381         lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
    382         lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
    383        
    384         /* we have all connections found in the MIX_DevMask */
    385         lpMl->cConnections = 1; //waveout
    386         lpMl->cControls    = 1;
    387         lpMl->cChannels    = 2;
    388         break;
     154        break;
    389155
    390156    case MIXER_GETLINEINFOF_LINEID:
    391         if(lpMl->dwLineID >= SOUND_MIXER_MAXID)
    392             return MIXERR_INVALLINE;
    393 
    394         lpMl->cChannels     = 2;
    395         lpMl->dwDestination = 0; /* index for speakers */
    396         if(lpMl->dwLineID == SOUND_MIXER_WAVEOUT) {
    397                 lpMl->dwLineID      = SOUND_MIXER_WAVEOUT;
    398                 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
    399                 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
    400                 lpMl->cConnections  = 0;
    401                 lpMl->cControls     = 1;
    402                 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
    403                 lpMl->fdwLine        |= MIXERLINE_LINEF_SOURCE;
    404         }
    405         else {
    406                 lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
    407                 lpMl->dwSource = 0xFFFFFFFF;
    408                 lpMl->dwLineID = SOUND_MIXER_LINEOUT;
    409                 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
    410                 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
    411                 lpMl->cConnections  = 1;
    412                 lpMl->cControls     = 1;
    413         }
    414         break;
     157        break;
    415158
    416159    case MIXER_GETLINEINFOF_SOURCE:
    417         if(lpMl->dwSource != SOUND_MIXER_WAVEOUT)
    418             return MIXERR_INVALLINE;
    419 
    420         lpMl->dwLineID      = SOUND_MIXER_WAVEOUT;
    421         lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
    422         lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
    423         lpMl->cConnections  = 0;
    424         lpMl->cControls     = 1;
    425         lpMl->dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
    426         lpMl->fdwLine        |= MIXERLINE_LINEF_SOURCE;
    427         lpMl->cChannels     = 2;
    428         lpMl->dwLineID      = SOUND_MIXER_WAVEOUT;
    429         lpMl->dwDestination = 0; /* index for speakers */
    430         break;
     160        break;
    431161
    432162    case MIXER_GETLINEINFOF_COMPONENTTYPE:
    433         switch (lpMl->dwComponentType)
    434         {
    435         case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
    436                 lpMl->dwDestination = 0;
    437                 lpMl->dwSource = 0xFFFFFFFF;
    438                 lpMl->dwLineID = SOUND_MIXER_LINEOUT;
    439                 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_LINEOUT_A, MIXER_SHORT_NAME_CHARS);
    440                 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_LINEOUT_A, MIXER_LONG_NAME_CHARS);
     163            switch (lpMl->dwComponentType)
     164            {
     165            case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
    441166                break;
    442         case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
    443                 lpMl->dwLineID = SOUND_MIXER_WAVEOUT;
    444                 lpMl->fdwLine |= MIXERLINE_LINEF_SOURCE;
    445                 lstrcpynA(lpMl->szShortName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_SHORT_NAME_CHARS);
    446                 lstrcpynA(lpMl->szName, WINMM_SHORTNAME_WAVEOUT_A, MIXER_LONG_NAME_CHARS);
    447                 break;
    448         default:
     167        case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT:
     168                break;
     169        default:
    449170                dprintf(("Unhandled component type (%08lx)\n", lpMl->dwComponentType));
    450171                return MMSYSERR_INVALPARAM;
    451         }
     172            }
    452173        lpMl->cConnections  = 0;
    453174        lpMl->cControls     = 1;
    454175        lpMl->cChannels     = 2;
    455         break;
     176            break;
    456177
    457178    case MIXER_GETLINEINFOF_TARGETTYPE:
    458         dprintf(("_TARGETTYPE not implemented yet.\n"));
    459         break;
     179            dprintf(("_TARGETTYPE not implemented yet.\n"));
     180            break;
    460181    default:
    461         dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
    462         break;
     182            dprintf(("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK));
     183            break;
    463184    }
    464185   
     
    490211UINT WINAPI mixerGetNumDevs()
    491212{
    492   if(DartWaveOut::getNumDevices() == 0) {
     213    if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
    493214        return 0;
    494   }
    495   return 1;
     215    }
     216    return 1;
     217}
     218/******************************************************************************/
     219/******************************************************************************/
     220MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
     221{
     222    if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
     223        return MMSYSERR_BADDEVICEID;
     224    }
     225
     226    if(uMxId > 0) {
     227        return MMSYSERR_BADDEVICEID;
     228    }
     229
     230    //According to MSDN, nothing is copied when cbmxcaps is zero
     231    if(cbmxcaps >= sizeof(MIXERCAPSA)) {
     232        // we have to fill in this thing
     233        pmxcaps->wMid = 0;                  /* manufacturer ID */
     234        pmxcaps->wPid = 0;                  /* product ID */
     235        pmxcaps->vDriverVersion = 0x0001;        /* version of the driver */
     236        strcpy( pmxcaps->szPname, WINMM_MIXERSTRING_A); /* product name */
     237
     238        pmxcaps->fdwSupport    = 0;    //no mixer flags exist
     239        pmxcaps->cDestinations = 1;
     240    }
     241
     242    return MMSYSERR_NOERROR;
     243}
     244/******************************************************************************/
     245/******************************************************************************/
     246MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
     247{
     248    if(fMMPMAvailable == FALSE || DartWaveOut::getNumDevices() == 0) {
     249        return MMSYSERR_BADDEVICEID;
     250    }
     251
     252    if(uMxId > 0) {
     253        return MMSYSERR_BADDEVICEID;
     254    }
     255
     256    //According to MSDN, nothing is copied when cbmxcaps is zero
     257    if(cbmxcaps >= sizeof(MIXERCAPSW)) {
     258        // we have to fill in this thing
     259        pmxcaps->wMid = 0;                  /* manufacturer ID */
     260        pmxcaps->wPid = 0;                  /* product ID */
     261        pmxcaps->vDriverVersion = 0x0001;        /* version of the driver */
     262        lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
     263
     264        pmxcaps->fdwSupport    = 0;    //no mixer flags exist
     265        pmxcaps->cDestinations = 1;
     266    }
     267
     268    return MMSYSERR_NOERROR;
     269}
     270/******************************************************************************/
     271/******************************************************************************/
     272MMRESULT WINAPI mixerGetID(HMIXEROBJ hmxobj, UINT * puMxId, DWORD fdwId)
     273{
     274    DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
     275
     276    if(!pMixInfo) {
     277        return MMSYSERR_INVALHANDLE;
     278    }
     279
     280    if(puMxId) {
     281        *puMxId = pMixInfo->uDeviceID;
     282    }
     283    else *puMxId = 0;
     284    return MMSYSERR_NOERROR;
    496285}
    497286/******************************************************************************/
     
    503292
    504293    if(DartWaveOut::getNumDevices() == 0) {
    505             if(phmx) *phmx = 0;
    506             return MMSYSERR_NODRIVER;
    507     }
    508       pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
     294        if(phmx) *phmx = 0;
     295        return MMSYSERR_NODRIVER;
     296    }
     297    pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
    509298    if(pMixInfo == NULL) {
    510299        return MMSYSERR_NODRIVER;
     
    530319/******************************************************************************/
    531320/******************************************************************************/
    532 
    533 
     321BOOL mixerInit()
     322{
     323    if(!fMMPMAvailable) return TRUE;
     324
     325    if(OSLibMixerOpen() == FALSE) {
     326        return FALSE;
     327    }
     328    return TRUE;
     329}
     330/******************************************************************************/
     331/******************************************************************************/
     332void mixerExit()
     333{
     334    OSLibMixerClose();
     335}
     336/******************************************************************************/
     337/******************************************************************************/
     338
  • trunk/src/winmm/winmm.mak

    r8470 r8472  
    1 # $Id: winmm.mak,v 1.9 2002-05-22 15:50:26 sandervl Exp $
     1# $Id: winmm.mak,v 1.10 2002-05-22 20:19:11 sandervl Exp $
    22
    33#
     
    4242$(OBJDIR)\auxos2.obj \
    4343$(OBJDIR)\mixer.obj \
     44$(OBJDIR)\mixeros2.obj \
    4445$(OBJDIR)\midi.obj \
    4546$(OBJDIR)\irtmidi.obj \
Note: See TracChangeset for help on using the changeset viewer.