Changeset 8470 for trunk/src


Ignore:
Timestamp:
May 22, 2002, 5:50:26 PM (23 years ago)
Author:
sandervl
Message:

added debug wrappers (.def)

Location:
trunk/src/winmm
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/auxiliary.cpp

    r2812 r8470  
    1 /* $Id: auxiliary.cpp,v 1.3 2000-02-17 14:09:30 sandervl Exp $ */
     1/* $Id: auxiliary.cpp,v 1.4 2002-05-22 15:50:24 sandervl Exp $ */
    22
    33/*
    … …  
    3131#include "dbglocal.h"
    3232
    33 ODINDEBUGCHANNEL(WINMM-AUX)
    34 
    3533/******************************************************************************/
    3634/******************************************************************************/
    37 ODINFUNCTION3(MMRESULT, auxGetDevCapsA,
    38               UINT, uDeviceID,
    39               LPAUXCAPSA, pac,
    40               UINT, cbac)
     35MMRESULT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA pac, UINT cbac)
    4136{
    4237  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    6055/******************************************************************************/
    6156/******************************************************************************/
    62 ODINFUNCTION3(MMRESULT, auxGetDevCapsW,
    63               UINT, uDeviceID,
    64               LPAUXCAPSW, pac,
    65               UINT, cbac)
     57MMRESULT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW pac, UINT cbac)
    6658{
    6759  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    8577/******************************************************************************/
    8678/******************************************************************************/
    87 ODINFUNCTION2(MMRESULT, auxSetVolume,
    88               UINT, uDeviceID,
    89               DWORD, dwVolume)
     79MMRESULT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
    9080{
    9181  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    10292/******************************************************************************/
    10393/******************************************************************************/
    104 ODINFUNCTION2(MMRESULT, auxGetVolume,
    105               UINT, uDeviceID,
    106               LPDWORD, pdwVolume)
     94MMRESULT WINAPI auxGetVolume(UINT uDeviceID, LPDWORD pdwVolume)
    10795{
    10896  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    119107/******************************************************************************/
    120108/******************************************************************************/
    121 ODINFUNCTION0(UINT, auxGetNumDevs)
     109UINT WINAPI auxGetNumDevs()
    122110{
    123111  if(auxOS2Open() == FALSE)
    … …  
    128116/******************************************************************************/
    129117/******************************************************************************/
    130 ODINFUNCTION4(MMRESULT, auxOutMessage,
    131               UINT, uDeviceID,
    132               UINT, uMsg,
    133               DWORD, dwParam1,
    134               DWORD, dwParam2)
     118MMRESULT WINAPI auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD dwParam1,
     119                              DWORD dwParam2)
    135120{
    136121  if(uDeviceID == AUX_MAPPER) {//AUX mapper

  • trunk/src/winmm/joy.cpp

    r5472 r8470  
    1 /* $Id: joy.cpp,v 1.9 2001-04-04 09:02:16 sandervl Exp $ */
     1/* $Id: joy.cpp,v 1.10 2002-05-22 15:50:24 sandervl Exp $ */
    22/*
    33 * Odin Joystick apis
    … …  
    2929#include "dbglocal.h"
    3030
    31 ODINDEBUGCHANNEL(WINMM-JOY)
    32 
    33 
    3431#define MAXJOYDRIVERS 2
    3532
    … …  
    9996 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 10:00]
    10097 */
    101 ODINFUNCTION0(UINT, joyGetNumDevs)
     98UINT WINAPI joyGetNumDevs()
    10299{
    103100  HANDLE            hJoy;
    … …  
    134131 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:40]
    135132 */
    136 ODINFUNCTION3(MMRESULT, joyGetDevCapsW,
    137               UINT, wID,
    138               LPJOYCAPSW, lpCaps,
    139               UINT, wSize)
     133MMRESULT WINAPI joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps, UINT wSize)
    140134{
    141135    if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    … …  
    176170
    177171/**
    178  * Get Joystick capatibities (Unicode)
     172 * Get Joystick capatibities (Ascii)
    179173 * @status      Completely Done
    180174 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    181175 */
    182 ODINFUNCTION3(MMRESULT, joyGetDevCapsA,
    183               UINT, wID,
    184               LPJOYCAPSA, lpCaps,
    185               UINT, wSize)
     176MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
    186177{
    187178    if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    … …  
    227218 *              running with this function.
    228219 */
    229 ODINFUNCTION2(MMRESULT, joyGetPosEx,
    230               UINT, uJoyID,
    231               LPJOYINFOEX, pji)
     220MMRESULT WINAPI joyGetPosEx(UINT uJoyID, LPJOYINFOEX pji)
    232221{
    233222  JOYINFO            ji;
    … …  
    315304 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    316305 */
    317 ODINFUNCTION2(MMRESULT, joyGetPos,
    318               UINT, uJoyID,
    319               LPJOYINFO, pji)
     306MMRESULT WINAPI joyGetPos(UINT uJoyID, LPJOYINFO pji)
    320307{
    321308  HANDLE   hGame;
    … …  
    341328 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    342329 */
    343 ODINFUNCTION2(MMRESULT, joyGetThreshold,
    344               UINT, wID,
    345               LPUINT, lpThreshold)
     330MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
    346331{
    347332    dprintf(("WINMM:joyGetThreshold %d %X\n",wID, lpThreshold));
    … …  
    358343 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    359344 */
    360 ODINFUNCTION2(MMRESULT, joySetThreshold,
    361               UINT, wID,
    362               UINT, wThreshold)
     345MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
    363346{
    364347   if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    … …  
    383366 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    384367 */
    385 ODINFUNCTION4(MMRESULT, joySetCapture,
    386               HWND, hWnd,
    387               UINT, wID,
    388               UINT, wPeriod,
    389               BOOL, bChanged)
     368MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL bChanged)
    390369{
    391370   JOYTHREADOPT *newthr;
    … …  
    422401 * @remark      Must be rewritten.
    423402 */
    424 ODINFUNCTION1(MMRESULT, joyReleaseCapture,
    425               UINT, wID)
     403MMRESULT WINAPI joyReleaseCapture(UINT wID)
    426404{
    427405  // TODO: Semaphores or waiting for thread...
    … …  
    439417 * @author      Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    440418 */
    441 ODINFUNCTION1(MMRESULT, joyConfigChanged,
    442               DWORD, dwFlags)
     419MMRESULT WINAPI joyConfigChanged(DWORD dwFlags)
    443420{
    444421  return JOYERR_NOERROR;

  • trunk/src/winmm/mci.cpp

    r5472 r8470  
    1 /* $Id: mci.cpp,v 1.7 2001-04-04 09:02:16 sandervl Exp $ */
     1/* $Id: mci.cpp,v 1.8 2002-05-22 15:50:24 sandervl Exp $ */
    22
    33/*
    … …  
    3535
    3636#define DBG_LOCALLOG    DBG_mci
    37 
    3837#include "dbglocal.h"
    3938
    … …  
    5453/****************************************************************************/
    5554
    56 ODINDEBUGCHANNEL(WINMM-MCI)
    57 
    58 
    59 ODINFUNCTION3(BOOL, mciDriverNotify,
    60               HWND, hwndCallback,
    61               UINT, uDeviceID,
    62               UINT, uStatus)
     55
     56BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
    6357{
    6458  TRACE("Entering mciDriverNotify (%08X, %04x, %04X)\n", hwndCallback, uDeviceID, uStatus);
    … …  
    7367}
    7468
    75 ODINFUNCTION1(UINT, mciDriverYield,
    76               UINT, uDeviceID)
     69UINT WINAPI mciDriverYield(UINT uDeviceID)
    7770{
    7871  dprintf(("WINMM:mciDriverYield - stub\n"));
    … …  
    8073}
    8174
    82 ODINFUNCTION1(BOOL, mciExecute,
    83               LPCSTR, pszCommand)
     75BOOL WINAPI mciExecute(LPCSTR pszCommand)
    8476{
    8577  dprintf(("WINMM:mciExecute(%s) - stub\n", pszCommand));
    … …  
    8779}
    8880
    89 ODINFUNCTION1(BOOL, mciFreeCommandResource,
    90               UINT, uTable)
     81BOOL WINAPI mciFreeCommandResource(UINT uTable)
    9182{
    9283  dprintf(("WINMM:mciFreeCommandResource - stub\n"));
    … …  
    9485}
    9586
    96 ODINFUNCTION1(HTASK, mciGetCreatorTask,
    97               MCIDEVICEID, mciId)
     87HTASK mciGetCreatorTask(MCIDEVICEID mciId)
    9888{
    9989  dprintf(("WINMM:mciGetCreatorTask - stub\n"));
    … …  
    10191}
    10292
    103 ODINFUNCTION1(MCIDEVICEID, mciGetDeviceIDA,
    104               LPCSTR, pszDevice)
     93MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR pszDevice)
    10594{
    10695  WARN(("WINMM:mciGetDeviceIDA - untested\n"));
    … …  
    10897}
    10998
    110 ODINFUNCTION1(MCIDEVICEID, mciGetDeviceIDW,
    111               LPCWSTR, pszDevice)
     99MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR pszDevice)
    112100{
    113101  dprintf(("WINMM:mciGetDeviceIDW - stub\n"));
    … …  
    115103}
    116104
    117 ODINFUNCTION2(MCIDEVICEID, mciGetDeviceIDFromElementIDA,
    118               DWORD, dwElementID,
    119               LPCSTR, lpstrType)
     105MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType)
    120106{
    121107  dprintf(("WINMM:mciGetDeviceIDFromElementIDA - stub\n"));
    … …  
    123109}
    124110
    125 ODINFUNCTION2(MCIDEVICEID, mciGetDeviceIDFromElementIDW,
    126               DWORD, dwElementID,
    127               LPCWSTR, lpstrType)
     111MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
    128112{
    129113  dprintf(("WINMM:mciGetDeviceIDFromElementIDW - stub\n"));
    … …  
    141125 * @author   : Chris Wohlgemuth [Sun, 2000/11/19]
    142126 *****************************************************************************/
    143 ODINFUNCTION1(DWORD, mciGetDriverData,
    144               UINT, uDeviceID)
     127DWORD WINAPI mciGetDriverData(UINT uDeviceID)
    145128{
    146129  LPWINE_MCIDRIVER      wmd;
    … …  
    168151 * @author   : Wine
    169152 *****************************************************************************/
    170 ODINFUNCTION3(BOOL, mciGetErrorStringA,
    171               MCIERROR, mcierr,
    172               LPSTR, pszText,
    173               UINT, cchText)
     153BOOL WINAPI mciGetErrorStringA(MCIERROR mcierr, LPSTR pszText, UINT cchText)
    174154{
    175155  dprintf(("WINMM:mciGetErrorStringA(%d)\n", mcierr ));
    … …  
    198178 * @author   : Wine
    199179 *****************************************************************************/
    200 ODINFUNCTION3(BOOL, mciGetErrorStringW,
    201               MCIERROR, mcierr,
    202               LPWSTR, pszText,
    203               UINT, cchText)
     180BOOL WINAPI mciGetErrorStringW(MCIERROR mcierr, LPWSTR pszText, UINT cchText)
    204181{
    205182  dprintf(("WINMM:mciGetErrorStringW(%d)\n", mcierr ));
    … …  
    228205 * @author    : Wine
    229206 *****************************************************************************/
    230 ODINFUNCTION2(YIELDPROC, mciGetYieldProc,
    231               MCIDEVICEID, mciId,
    232               LPDWORD, pdwYieldData)
     207YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID  mciId, LPDWORD pdwYieldData)
    233208{
    234209  LPWINE_MCIDRIVER      wmd;
    … …  
    251226}
    252227
    253 ODINFUNCTION3(UINT, mciLoadCommandResource,
    254               HINSTANCE, hInstance,
    255               LPCWSTR, lpResName,
    256               UINT, uType)
     228UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName,
     229                                   UINT uType)
    257230{
    258231  dprintf(("WINMM:mciLoadCOmmandResource - stub\n"));
    … …  
    261234
    262235
    263 ODINFUNCTION4(MCIERROR, mciSendCommandA,
    264               MCIDEVICEID, mciId,
    265               UINT, uMsg,
    266               DWORD, dwParam1,
    267               DWORD, dwParam2)
     236MCIERROR WINAPI mciSendCommandA(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1,
     237                                DWORD dwParam2)
    268238{
    269239  DWORD dwRet;
    … …  
    274244
    275245
    276 ODINFUNCTION4(MCIERROR, mciSendCommandW,
    277               MCIDEVICEID, mciId,
    278               UINT, uMsg,
    279               DWORD, dwParam1,
    280               DWORD, dwParam2)
     246MCIERROR WINAPI mciSendCommandW(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1,
     247                                DWORD dwParam2)
    281248{
    282249  dprintf(("WINMM:mciSendCommandW - stub %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
    … …  
    284251}
    285252
    286 ODINFUNCTION4(MCIERROR, mciSendStringA,
    287               LPCSTR, lpstrCommand,
    288               LPSTR, lpstrReturnString,
    289               UINT, uReturnLength,
    290               HWND, hwndCallback)
     253MCIERROR WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
     254                               UINT uReturnLength, HWND hwndCallback)
    291255{
    292256  dprintf(("WINMM:mciSendStringA - stub\n"));
    … …  
    296260}
    297261
    298 ODINFUNCTION4(MCIERROR, mciSendStringW,
    299               LPCWSTR, lpstrCommand,
    300               LPWSTR, lpstrReturnString,
    301               UINT, uReturnLength,
    302               HWND, hwndCallback)
     262MCIERROR WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString,
     263                               UINT uReturnLength, HWND hwndCallback)
    303264{
    304265  dprintf(("WINMM:mciSendStringW - stub\n"));
    … …  
    306267}
    307268
    308 ODINFUNCTION2(BOOL, mciSetDriverData,
    309               UINT, uDeviceID,
    310               DWORD, dwData)
     269BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData)
    311270{
    312271  LPWINE_MCIDRIVER      wmd;
    … …  
    324283
    325284
    326 ODINFUNCTION3(BOOL, mciSetYieldProc,
    327               MCIDEVICEID, mciId,
    328               YIELDPROC, fpYieldProc,
    329               DWORD, dwYieldData)
     285BOOL WINAPI mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData)
    330286{
    331287  LPWINE_MCIDRIVER      wmd;

  • trunk/src/winmm/midi.cpp

    r5272 r8470  
    1 /* $Id: midi.cpp,v 1.9 2001-02-27 21:13:59 sandervl Exp $ */
     1/* $Id: midi.cpp,v 1.10 2002-05-22 15:50:24 sandervl Exp $ */
    22
    33/*
    … …  
    3131#include "dbglocal.h"
    3232
    33 ODINDEBUGCHANNEL(WINMM-MIDI)
    34 
    35 //SvL: 23/09/99: WinPostMsg no longer works, as win32 window handles are no longer PM handles
    36 BOOL WIN32API PostMessageA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
    37 
    3833/*
    3934   Work to do:
    … …  
    119114
    120115/******************************************************************************/
    121 ODINFUNCTION3(MMRESULT, midiConnect,
    122               HMIDI, hMidiIn,
    123               HMIDIOUT, hMidiOut,
    124               LPVOID, pReserved)
     116MMRESULT WINAPI midiConnect(HMIDI hMidiIn, HMIDIOUT hMidiOut, LPVOID pReserved)
    125117{
    126118  // TODO: Implement using instance connections
    … …  
    142134
    143135/******************************************************************************/
    144 ODINFUNCTION3(MMRESULT, midiDisconnect,
    145               HMIDI, hMidiIn,
    146               HMIDIOUT, hMidiOut,
    147               LPVOID, pReserved)
     136MMRESULT WINAPI midiDisconnect(HMIDI hMidiIn, HMIDIOUT hMidiOut, LPVOID pReserved)
    148137{
    149138  // TODO: Implement using instance connections
    … …  
    165154
    166155/******************************************************************************/
    167 ODINFUNCTION3(MMRESULT, midiInAddBuffer,
    168               HMIDIIN, hMidiIn,
    169               LPMIDIHDR, lpMidiInHdr,
    170               UINT, cbMidiInHdr)
     156MMRESULT WINAPI midiInAddBuffer(HMIDIIN hMidiIn, LPMIDIHDR lpMidiInHdr, UINT cbMidiInHdr)
    171157{
    172158  dprintf(("WINMM:midiInAddBuffer -- not Implemented\n" ));
    … …  
    183169
    184170/******************************************************************************/
    185 ODINFUNCTION1(MMRESULT, midiInClose,
    186               HMIDIIN, hMidiIn)
     171MMRESULT WINAPI midiInClose(HMIDIIN hMidiIn)
    187172{
    188173  dprintf(("WINMM:midiInClose -- partially Implemented\n" ));
    … …  
    200185
    201186/******************************************************************************/
    202 ODINFUNCTION3(MMRESULT, midiInGetDevCapsA,
    203               UINT, uDeviceId,
    204               LPMIDIINCAPSA, midiInCaps,
    205               UINT,  sMidiInCaps)
     187MMRESULT WINAPI midiInGetDevCapsA(UINT uDeviceId, LPMIDIINCAPSA midiInCaps,
     188                                  UINT sMidiInCaps)
    206189{
    207190  dprintf(("WINMM:midiInGetDevCapsA(%u)\n", uDeviceId ));
    … …  
    229212
    230213/******************************************************************************/
    231 ODINFUNCTION3(MMRESULT, midiInGetDevCapsW,
    232               UINT, uDeviceId,
    233               LPMIDIINCAPSW, midiInCaps,
    234               UINT,  sMidiInCaps )
     214MMRESULT WINAPI midiInGetDevCapsW(UINT uDeviceId, LPMIDIINCAPSW midiInCaps,
     215                                  UINT sMidiInCaps )
    235216{
    236217  dprintf(("WINMM:midiInGetDevCapsA(%u)\n", uDeviceId ));
    … …  
    259240
    260241/******************************************************************************/
    261 ODINFUNCTION3(MMRESULT, midiInGetErrorTextA,
    262               MMRESULT, wError,
    263               LPSTR, lpText,
    264               UINT, cchText)
     242MMRESULT WINAPI midiInGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
    265243{
    266244  dprintf(("WINMM:midiInGetErrorTextA(%d)\n", wError ));
    … …  
    278256
    279257/******************************************************************************/
    280 ODINFUNCTION3(MMRESULT, midiInGetErrorTextW,
    281               MMRESULT, wError,
    282               LPWSTR, lpText,
    283               UINT, cchText)
     258MMRESULT WINAPI midiInGetErrorTextW(MMRESULT wError, LPWSTR lpText,
     259                                    UINT cchText)
    284260{
    285261  dprintf(("WINMM:midiInGetErrorTextW(%d)\n", wError ));
    … …  
    297273
    298274/******************************************************************************/
    299 ODINFUNCTION2(MMRESULT, midiInGetID,
    300               HMIDIIN, hMidiIn,
    301               LPUINT, puDeviceID)
     275MMRESULT WINAPI midiInGetID(HMIDIIN hMidiIn, LPUINT puDeviceID)
    302276{
    303277  dprintf(("WINMM:midiInGetID\n" ));
    … …  
    316290
    317291/******************************************************************************/
    318 ODINFUNCTION4(UINT, midiInMessage,
    319               HMIDIIN, hmi,
    320               UINT, msg,
    321               DWORD, dw1,
    322               DWORD, dw2)
     292UINT WINAPI midiInMessage(HMIDIIN hmi, UINT msg, DWORD dw1, DWORD dw2)
    323293{
    324294  dprintf(("WINMM:midiInMessage -- not Implemented\n" ));
    … …  
    327297
    328298/******************************************************************************/
    329 ODINFUNCTION0(UINT, midiInGetNumDevs)
     299UINT WINAPI midiInGetNumDevs()
    330300{
    331301  UINT i = IRTMIDI->numInInstances();
    … …  
    334304
    335305/******************************************************************************/
    336 ODINFUNCTION5(MMRESULT, midiInOpen,
    337               LPHMIDIIN, lphMidiIn,
    338               UINT, uDeviceId,
    339               DWORD, dwCallback,
    340               DWORD, dwCallbackInstance,
    341               DWORD, dwflags)
     306MMRESULT WINAPI midiInOpen(LPHMIDIIN lphMidiIn, UINT uDeviceId, DWORD dwCallback,
     307                           DWORD dwCallbackInstance, DWORD dwflags)
    342308{
    343309  dprintf(("WINMM:midiInOpen(%d) --  partial Implementation\n", uDeviceId ));
    … …  
    360326
    361327/******************************************************************************/
    362 ODINFUNCTION3(MMRESULT, midiInPrepareHeader,
    363               HMIDIIN, hMidiIn,
    364               LPMIDIHDR, lpMidiInHdr,
    365               UINT, cbMidiInHdr)
     328MMRESULT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn, LPMIDIHDR lpMidiInHdr,
     329                                    UINT cbMidiInHdr)
    366330{
    367331  dprintf(("WINMM:midiInPrepareHeader -- not Implemented\n" ));
    … …  
    379343
    380344/******************************************************************************/
    381 ODINFUNCTION1(MMRESULT, midiInReset,
    382               HMIDIIN, hMidiIn)
     345MMRESULT WINAPI midiInReset(HMIDIIN hMidiIn)
    383346{
    384347  dprintf(("WINMM:midiInReset -- not Implemented\n" ));
    … …  
    395358
    396359/******************************************************************************/
    397 ODINFUNCTION1(MMRESULT, midiInStart,
    398               HMIDIIN, hMidiIn)
     360MMRESULT WINAPI midiInStart(HMIDIIN hMidiIn)
    399361{
    400362  dprintf(("WINMM:midiInStart\n" ));
    … …  
    411373
    412374/******************************************************************************/
    413 ODINFUNCTION1(MMRESULT, midiInStop,
    414               HMIDIIN, hMidiIn)
     375MMRESULT WINAPI midiInStop(HMIDIIN hMidiIn)
    415376{
    416377  dprintf(("WINMM:midiInStop\n" ));
    … …  
    427388
    428389/******************************************************************************/
    429 ODINFUNCTION3(MMRESULT, midiInUnprepareHeader,
    430               HMIDIIN, hMidiIn,
    431               LPMIDIHDR, lpMidiInHdr,
    432               UINT, cbMidiInHdr)
     390MMRESULT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
     391                                      LPMIDIHDR lpMidiInHdr,
     392                                      UINT cbMidiInHdr)
    433393{
    434394  dprintf(("WINMM:midiInUnPrepareHeader -- not Implemented\n" ));
    … …  
    445405
    446406/******************************************************************************/
    447 ODINFUNCTION4(MMRESULT, midiOutCacheDrumPatches,
    448               HMIDIOUT, hMidiOut,
    449               UINT, wPatch,
    450               WORD *, lpKeyArray,
    451               UINT, wFlags)
     407MMRESULT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut,
     408                                        UINT wPatch,
     409                                        WORD *lpKeyArray,
     410                                        UINT wFlags)
    452411{
    453412  // Valid only for an Internal synth.  So we won't do it for now.
    … …  
    465424
    466425/******************************************************************************/
    467 ODINFUNCTION4(MMRESULT, midiOutCachePatches,
    468               HMIDIOUT, hMidiOut,
    469               UINT, wBank,
    470               WORD *, lpPatchArray,
    471               UINT, wFlags)
     426MMRESULT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut,
     427                                    UINT wBank,
     428                                    WORD *lpPatchArray,
     429                                    UINT wFlags)
    472430{
    473431  // Valid only for an Internal synth.  So we won't do it for now.
    … …  
    485443
    486444/******************************************************************************/
    487 ODINFUNCTION1(MMRESULT, midiOutClose,
    488               HMIDIOUT, hMidiOut)
     445MMRESULT WINAPI midiOutClose(HMIDIOUT hMidiOut)
    489446{
    490447  dprintf(("WINMM:midiOutClose - partially implemented\n" ));
    … …  
    503460
    504461/******************************************************************************/
    505 ODINFUNCTION3(MMRESULT, midiOutGetDevCapsA,
    506               UINT, uDeviceId,
    507               LPMIDIOUTCAPSA, midiOutCaps,
    508               UINT,  sMidiOutCaps )
     462MMRESULT WINAPI midiOutGetDevCapsA(UINT uDeviceId, LPMIDIOUTCAPSA midiOutCaps,
     463                                   UINT sMidiOutCaps )
    509464{
    510465  // TODO: Actually fill in the important fields
    … …  
    554509
    555510/******************************************************************************/
    556 ODINFUNCTION3(MMRESULT, midiOutGetDevCapsW,
    557               UINT, uDeviceId,
    558               LPMIDIOUTCAPSW, midiOutCaps,
    559               UINT,  sMidiOutCaps )
     511MMRESULT WINAPI midiOutGetDevCapsW(UINT uDeviceId, LPMIDIOUTCAPSW midiOutCaps,
     512                                   UINT sMidiOutCaps )
    560513{
    561514  // TODO: Actually fill in the important fields
    … …  
    607560
    608561/******************************************************************************/
    609 ODINFUNCTION3(MMRESULT, midiOutGetErrorTextA,
    610               MMRESULT, wError,
    611               LPSTR, lpText,
    612               UINT, cchText)
     562MMRESULT WINAPI midiOutGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
    613563{
    614564  dprintf(("WINMM:midiOutGetErrorTextA(%d)\n", wError ));
    … …  
    626576
    627577/******************************************************************************/
    628 ODINFUNCTION3(MMRESULT, midiOutGetErrorTextW,
    629               MMRESULT, wError,
    630               LPWSTR, lpText,
    631               UINT, cchText)
     578MMRESULT WINAPI midiOutGetErrorTextW(MMRESULT wError, LPWSTR lpText, UINT cchText)
    632579{
    633580  dprintf(("WINMM:midiOutGetErrorTextW(%d) - need to translate\n", wError ));
    … …  
    645592
    646593/******************************************************************************/
    647 ODINFUNCTION2(MMRESULT, midiOutGetID,
    648               HMIDIOUT, hMidiOut,
    649               LPUINT, puDeviceID)
     594MMRESULT WINAPI midiOutGetID(HMIDIOUT hMidiOut,LPUINT puDeviceID)
    650595{
    651596  dprintf(("WINMM:midiOutGetID\n" ));
    … …  
    663608
    664609/******************************************************************************/
    665 ODINFUNCTION0(UINT, midiOutGetNumDevs)
     610UINT WINAPI midiOutGetNumDevs()
    666611{
    667612  UINT i = IRTMIDI->numOutInstances();
    … …  
    670615
    671616/******************************************************************************/
    672 ODINFUNCTION2(MMRESULT, midiOutGetVolume,
    673               HMIDIOUT, hMidiOut,
    674               LPDWORD, lpdwVolume)
     617MMRESULT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, LPDWORD lpdwVolume)
    675618{
    676619  MMRESULT rc;
    … …  
    687630
    688631/******************************************************************************/
    689 ODINFUNCTION3(MMRESULT, midiOutLongMsg,
    690               HMIDIOUT, hMidiOut,
    691               LPMIDIHDR, lpMidiOutHdr,
    692               UINT, cbMidiOutHdr)
     632MMRESULT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut, LPMIDIHDR lpMidiOutHdr,
     633                               UINT cbMidiOutHdr)
    693634{
    694635  // TODO: Implement this
    … …  
    708649
    709650/******************************************************************************/
    710 ODINFUNCTION4(UINT, midiOutMessage,
    711               HMIDIOUT, hMidiOut,
    712               UINT, msg,
    713               DWORD, dw1,
    714               DWORD, dw2)
     651UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT msg, DWORD dw1, DWORD dw2)
    715652{
    716653  // TODO: Need to find out wha drivers actually return.
    … …  
    720657
    721658/******************************************************************************/
    722 ODINFUNCTION5(MMRESULT, midiOutOpen,
    723               LPHMIDIOUT, lphMidiOut,
    724               UINT, uDeviceId,
    725               DWORD, dwCallback,
    726               DWORD, dwCallbackInstance,
    727               DWORD, dwflags)
     659MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceId,
     660                            DWORD dwCallback, DWORD dwCallbackInstance,
     661                            DWORD dwflags)
    728662{
    729663  // TODO: - Handle thread callback, if any program really needs it
    … …  
    761695
    762696/******************************************************************************/
    763 ODINFUNCTION3(MMRESULT, midiOutPrepareHeader,
    764               HMIDIOUT, hMidiOut,
    765               LPMIDIHDR, lpMidiOutHdr,
    766               UINT, cbMidiOutHdr)
     697MMRESULT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut, LPMIDIHDR lpMidiOutHdr,
     698                                     UINT cbMidiOutHdr)
    767699{
    768700  // TODO: Either implement or treat as a NOOP as we may not need to "prepare"
    … …  
    781713
    782714/******************************************************************************/
    783 ODINFUNCTION1(MMRESULT, midiOutReset,
    784               HMIDIOUT, hMidiOut)
     715MMRESULT WINAPI midiOutReset(HMIDIOUT hMidiOut)
    785716{
    786717  // TODO: - return pending output buffers to callback
    … …  
    800731
    801732/******************************************************************************/
    802 ODINFUNCTION2(MMRESULT, midiOutSetVolume,
    803               HMIDIOUT, hMidiOut,
    804               DWORD, dwVolume)
     733MMRESULT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
    805734{
    806735  dprintf(("WINMM:midiOutSetVolume\n" ));
    … …  
    818747
    819748/******************************************************************************/
    820 ODINFUNCTION2(MMRESULT, midiOutShortMsg,
    821               HMIDIOUT, hMidiOut,
    822               DWORD, dwMsg)
     749MMRESULT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
    823750{
    824751  dprintf(("WINMM:midiOutShortMsg(%X)\n", dwMsg ));
    … …  
    836763
    837764/******************************************************************************/
    838 ODINFUNCTION3(MMRESULT, midiOutUnprepareHeader,
    839               HMIDIOUT, hMidiOut,
    840               LPMIDIHDR, lpMidiOutHdr,
    841               UINT, cbMidiOutHdr)
     765MMRESULT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut, LPMIDIHDR lpMidiOutHdr,
     766                                       UINT cbMidiOutHdr)
    842767{
    843768  // TODO: - return MIDIERR_STILLPLAYING if buffer is playing

  • trunk/src/winmm/midistrm.cpp

    r2812 r8470  
    1 /* $Id: midistrm.cpp,v 1.5 2000-02-17 14:09:31 sandervl Exp $ */
     1/* $Id: midistrm.cpp,v 1.6 2002-05-22 15:50:25 sandervl Exp $ */
    22
    33/*
    … …  
    2929
    3030
    31 ODINDEBUGCHANNEL(WINMM-MIDISTRM)
    32 
    33 
    3431/******************************************************************************/
    35 ODINFUNCTION1(MMRESULT, midiStreamClose,
    36               HMIDISTRM, hms)
     32MMRESULT WINAPI midiStreamClose(HMIDISTRM hms)
    3733{
    3834  dprintf(("WINMM:midiStreamClose - stub\n" ));
    … …  
    4339
    4440/******************************************************************************/
    45 ODINFUNCTION6(MMRESULT, midiStreamOpen,
    46               LPHMIDISTRM, phms,
    47               LPUINT, puDeviceID,
    48               DWORD, cMidi,
    49               DWORD, dwCallback,
    50               DWORD, dwInstance,
    51               DWORD, fdwOpen)
     41MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM phms, LPUINT puDeviceID,
     42                               DWORD cMidi, DWORD dwCallback,
     43                               DWORD dwInstance, DWORD fdwOpen)
    5244{
    5345  dprintf(("WINMM:midiStreamOpen - stub\n" ));
    … …  
    5850
    5951/******************************************************************************/
    60 ODINFUNCTION3(MMRESULT, midiStreamProperty,
    61               HMIDISTRM, hms,
    62               LPBYTE, lppropdata,
    63               DWORD, dwProperty)
     52MMRESULT WINAPI midiStreamProperty(HMIDISTRM hms, LPBYTE lppropdata,
     53                                   DWORD dwProperty)
    6454{
    6555  dprintf(("WINMM:midiStreamProperty - stub\n" ));
    … …  
    7060
    7161/******************************************************************************/
    72 ODINFUNCTION3(MMRESULT, midiStreamPosition,
    73               HMIDISTRM, hms,
    74               LPMMTIME, lpmmt,
    75               UINT, cbmmt)
     62MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt,
     63                                   UINT cbmmt)
    7664{
    7765  dprintf(("WINMM:midiStreamPosition - stub\n" ));
    … …  
    8270
    8371/******************************************************************************/
    84 ODINFUNCTION3(MMRESULT, midiStreamOut,
    85               HMIDISTRM, hms,
    86               LPMIDIHDR, pmh,
    87               UINT, cbmh)
     72MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh)
    8873{
    8974  dprintf(("WINMM:midiStreamOut - stub\n" ));
    … …  
    9479
    9580/******************************************************************************/
    96 ODINFUNCTION1(MMRESULT, midiStreamPause,
    97               HMIDISTRM, hms)
     81MMRESULT WINAPI midiStreamPause(HMIDISTRM hms)
    9882{
    9983  dprintf(("WINMM:midiStreamPause - stub\n" ));
    … …  
    10488
    10589/******************************************************************************/
    106 ODINFUNCTION1(MMRESULT, midiStreamRestart,
    107               HMIDISTRM, hms)
     90MMRESULT WINAPI midiStreamRestart(HMIDISTRM hms)
    10891{
    10992  dprintf(("WINMM:midiStreamRestart - stub\n" ));
    … …  
    11497
    11598/******************************************************************************/
    116 ODINFUNCTION1(MMRESULT, midiStreamStop,
    117               HMIDISTRM, hms)
     99MMRESULT WINAPI midiStreamStop(HMIDISTRM hms)
    118100{
    119101  dprintf(("WINMM:midiStreamStop - stub\n" ));

  • trunk/src/winmm/mixer.cpp

    r5926 r8470  
    1 /* $Id: mixer.cpp,v 1.10 2001-06-07 12:47:39 sandervl Exp $ */
     1/* $Id: mixer.cpp,v 1.11 2002-05-22 15:50:25 sandervl Exp $ */
    22
    33/*
    … …  
    3838
    3939
    40 ODINDEBUGCHANNEL(WINMM-MIXER)
    41 
    4240#define WINMM_MIXERSTRING_A     "OS/2 WINMM Mixer"
    4341#define WINMM_MIXERSTRING_W     (LPWSTR)L"OS/2 WINMM Mixer"
    … …  
    120118/******************************************************************************/
    121119/******************************************************************************/
    122 ODINFUNCTION3(MMRESULT, mixerGetControlDetailsA,
    123               HMIXEROBJ, hmxobj,
    124               LPMIXERCONTROLDETAILS, lpmcd,
    125               DWORD, fdwDetails)
     120MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
    126121{
    127122    DWORD       ret = MMSYSERR_NOTSUPPORTED;
    … …  
    187182/******************************************************************************/
    188183/******************************************************************************/
    189 ODINFUNCTION3(MMRESULT, mixerGetControlDetailsW,
    190               HMIXEROBJ, hmxobj,
    191               LPMIXERCONTROLDETAILS, pmxcd,
    192               DWORD, fdwDetails)
    193 {
    194   dprintf(("WINMM:mixerGetControlDetailsW - stub\n" ));
    195   return MIXERR_INVALCONTROL;
    196 }
    197 /******************************************************************************/
    198 /******************************************************************************/
    199 ODINFUNCTION3(MMRESULT, mixerSetControlDetails,
    200               HMIXEROBJ, hmxobj,
    201               LPMIXERCONTROLDETAILS, lpmcd,
    202               DWORD, fdwDetails)
     184MMRESULT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
     185{
     186    dprintf(("WINMM:mixerGetControlDetailsW - stub\n" ));
     187    return MIXERR_INVALCONTROL;
     188}
     189/******************************************************************************/
     190/******************************************************************************/
     191MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
    203192{
    204193    DWORD       ret = MMSYSERR_NOTSUPPORTED;
    … …  
    261250/******************************************************************************/
    262251/******************************************************************************/
    263 ODINFUNCTION3(MMRESULT, mixerGetLineControlsA,
    264               HMIXEROBJ, hmxobj,
    265               LPMIXERLINECONTROLSA, lpMlc,
    266               DWORD, fdwControls)
     252MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ  hmxobj, LPMIXERLINECONTROLSA lpMlc, DWORD fdwControls)
    267253{
    268254 DWORD dwRet = MMSYSERR_NOERROR;
    … …  
    277263    {
    278264    case MIXER_GETLINECONTROLSF_ALL:
    279         if (lpMlc->cControls != 2) {
     265            if (lpMlc->cControls != 2) {
     266            dwRet = MMSYSERR_INVALPARAM;
     267        }
     268        else {
     269                MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
     270                MIX_DoGetLineControls(&lpMlc->pamxctrl[1], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
     271            }
     272            break;
     273    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;
     278            break;
     279    case MIXER_GETLINECONTROLSF_ONEBYTYPE:
     280            switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
     281            case MIXERCONTROL_CT_CLASS_FADER:
     282            MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
     283                break;
     284            case MIXERCONTROL_CT_CLASS_SWITCH:
     285            MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
     286                break;
     287            default:
     288            dwRet = MMSYSERR_INVALPARAM;
     289        }
     290        break;
     291    default:
     292            dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
    280293            dwRet = MMSYSERR_INVALPARAM;
    281         }
    282         else {
    283             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
    284             MIX_DoGetLineControls(&lpMlc->pamxctrl[1], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
    285         }
    286         break;
    287     case MIXER_GETLINECONTROLSF_ONEBYID:
    288         if (MIX_SplitControlID(lpMlc->u.dwControlID, &lineID, &controlType))
    289             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lineID, controlType);
    290         else
    291             dwRet = MMSYSERR_INVALPARAM;
    292         break;
    293     case MIXER_GETLINECONTROLSF_ONEBYTYPE:
    294         switch (lpMlc->u.dwControlType & MIXERCONTROL_CT_CLASS_MASK) {
    295         case MIXERCONTROL_CT_CLASS_FADER:
    296             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_VOLUME);
    297             break;
    298         case MIXERCONTROL_CT_CLASS_SWITCH:
    299             MIX_DoGetLineControls(&lpMlc->pamxctrl[0], lpMlc->dwLineID, MIXERCONTROL_CONTROLTYPE_MUTE);
    300             break;
    301         default:
    302             dwRet = MMSYSERR_INVALPARAM;
    303         }
    304         break;
    305     default:
    306         dprintf(("Unknown flag %08lx\n", fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK));
    307         dwRet = MMSYSERR_INVALPARAM;
    308294    }
    309295
    … …  
    312298/******************************************************************************/
    313299/******************************************************************************/
    314 ODINFUNCTION3(MMRESULT, mixerGetLineControlsW,
    315               HMIXEROBJ, hmxobj,
    316               LPMIXERLINECONTROLSW, pmxlc,
    317               DWORD, fdwControls)
    318 {
    319   dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
    320   return MIXERR_INVALLINE;
    321 }
    322 /******************************************************************************/
    323 /******************************************************************************/
    324 ODINFUNCTION3(MMRESULT, mixerGetDevCapsA,
    325               UINT, uMxId,
    326               LPMIXERCAPSA, pmxcaps,
    327               UINT, cbmxcaps)
    328 {
    329   if(DartWaveOut::getNumDevices() == 0) {
     300MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls)
     301{
     302    dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
     303    return MIXERR_INVALLINE;
     304}
     305/******************************************************************************/
     306/******************************************************************************/
     307MMRESULT WINAPI mixerGetDevCapsA(UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
     308{
     309    if(DartWaveOut::getNumDevices() == 0) {
    330310        memset(pmxcaps, 0, sizeof(*pmxcaps));
    331311        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   strcpy( pmxcaps->szPname, WINMM_MIXERSTRING_A); /* product name */
    339 
    340   pmxcaps->fdwSupport = 0;
    341   pmxcaps->cDestinations = 1;
    342 
    343   return MMSYSERR_NOERROR;
    344 }
    345 /******************************************************************************/
    346 /******************************************************************************/
    347 ODINFUNCTION3(MMRESULT, mixerGetDevCapsW,
    348               UINT, uMxId,
    349               LPMIXERCAPSW, pmxcaps,
    350               UINT, cbmxcaps)
    351 {
    352   if(DartWaveOut::getNumDevices() == 0) {
     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/******************************************************************************/
     327MMRESULT WINAPI mixerGetDevCapsW(UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
     328{
     329    if(DartWaveOut::getNumDevices() == 0) {
    353330        memset(pmxcaps, 0, sizeof(*pmxcaps));
    354331        return MMSYSERR_NODRIVER;
    355   }
    356 
    357   // we have to fill in this thing
    358   pmxcaps->wMid = 0;                  /* manufacturer ID */
    359   pmxcaps->wPid = 0;                  /* product ID */
    360   pmxcaps->vDriverVersion = 0x0001;        /* version of the driver */
    361   lstrcpyW( pmxcaps->szPname, WINMM_MIXERSTRING_W ); /* product name */
    362 
    363   pmxcaps->fdwSupport = 0;
    364   pmxcaps->cDestinations = 1;
    365 
    366   return MMSYSERR_NOERROR;
    367 }
    368 /******************************************************************************/
    369 /******************************************************************************/
    370 ODINFUNCTION3(MMRESULT, mixerGetID,
    371               HMIXEROBJ, hmxobj,
    372               UINT *, puMxId,
    373               DWORD, fdwId)
    374 {
    375  DEVICE_STRUCT *pMixInfo = (DEVICE_STRUCT *)hmxobj;
    376 
    377   if(pMixInfo && puMxId) {
    378        *puMxId = pMixInfo->uDeviceID;
    379   }
    380   else *puMxId = 0;
    381   return MMSYSERR_NOERROR;
    382 }
    383 /******************************************************************************/
    384 /******************************************************************************/
    385 ODINFUNCTION3(MMRESULT, mixerGetLineInfoA,
    386               HMIXEROBJ, hmxobj,
    387               LPMIXERLINEA, lpMl,
    388               DWORD, fdwInfo)
     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/******************************************************************************/
     347MMRESULT 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;
     356}
     357/******************************************************************************/
     358/******************************************************************************/
     359MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA lpMl, DWORD fdwInfo)
    389360{
    390361    if (lpMl == NULL || lpMl->cbStruct != sizeof(*lpMl))
    391         return MMSYSERR_INVALPARAM;
     362            return MMSYSERR_INVALPARAM;
    392363   
    393364    /* FIXME: set all the variables correctly... the lines below
    … …  
    503474
    504475/******************************************************************************/
    505 ODINFUNCTION3(MMRESULT, mixerGetLineInfoW,
    506               HMIXEROBJ, hmxobj,
    507               LPMIXERLINEW, pmxl,
    508               DWORD, fdwInfo)
    509 {
    510   dprintf(("WINMM:mixerGetLineInfoW - stub\n" ));
    511   return MIXERR_INVALLINE;
    512 }
    513 /******************************************************************************/
    514 /******************************************************************************/
    515 ODINFUNCTION4(MMRESULT, mixerMessage,
    516               HMIXER, hmx,
    517               UINT, uMsg,
    518               DWORD, dwParam1,
    519               DWORD, dwParam2)
    520 {
    521   dprintf(("WINMM:mixerMessage - stub\n" ));
    522   return 0;
    523 }
    524 
    525 /******************************************************************************/
    526 ODINFUNCTION0(UINT, mixerGetNumDevs)
     476MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
     477{
     478    dprintf(("WINMM:mixerGetLineInfoW - stub\n" ));
     479    return MIXERR_INVALLINE;
     480}
     481/******************************************************************************/
     482/******************************************************************************/
     483MMRESULT WINAPI mixerMessage(HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
     484{
     485    dprintf(("WINMM:mixerMessage - stub\n" ));
     486    return 0;
     487}
     488/******************************************************************************/
     489/******************************************************************************/
     490UINT WINAPI mixerGetNumDevs()
    527491{
    528492  if(DartWaveOut::getNumDevices() == 0) {
    … …  
    533497/******************************************************************************/
    534498/******************************************************************************/
    535 ODINFUNCTION5(MMRESULT, mixerOpen,
    536               LPHMIXER, phmx,
    537               UINT, uMxId,
    538               DWORD, dwCallback,
    539               DWORD, dwInstance,
    540               DWORD, fdwOpen)
    541 {
    542  DEVICE_STRUCT *pMixInfo;
    543 
    544   if(DartWaveOut::getNumDevices() == 0) {
    545         if(phmx) *phmx = 0;
     499MMRESULT WINAPI mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance,
     500                          DWORD fdwOpen)
     501{
     502    DEVICE_STRUCT *pMixInfo;
     503
     504    if(DartWaveOut::getNumDevices() == 0) {
     505            if(phmx) *phmx = 0;
     506            return MMSYSERR_NODRIVER;
     507    }
     508      pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
     509    if(pMixInfo == NULL) {
    546510        return MMSYSERR_NODRIVER;
    547   }
    548   pMixInfo = (DEVICE_STRUCT *)malloc(sizeof(DEVICE_STRUCT));
    549   if(pMixInfo == NULL) {
    550         return MMSYSERR_NODRIVER;
    551   }
    552   pMixInfo->dwCallback = dwCallback;
    553   pMixInfo->dwDriverInstance = dwInstance;
    554   pMixInfo->dwFlags    = fdwOpen;
    555   pMixInfo->uDeviceID  = uMxId;
    556   pMixInfo->type       = WINMM_MIXER;
    557   if(phmx)
    558         *phmx = (HMIXER)pMixInfo;
    559   return MMSYSERR_NOERROR;
    560 }
    561 /******************************************************************************/
    562 /******************************************************************************/
    563 ODINFUNCTION1(MMRESULT, mixerClose,
    564               HMIXER, hmx)
    565 {
    566   if(hmx) {
    567         free((void *)hmx);
    568   }
    569   return MMSYSERR_NOERROR;
    570 }
    571 /******************************************************************************/
    572 /******************************************************************************/
    573 
    574 
     511    }
     512    pMixInfo->dwCallback = dwCallback;
     513    pMixInfo->dwDriverInstance = dwInstance;
     514    pMixInfo->dwFlags    = fdwOpen;
     515    pMixInfo->uDeviceID  = uMxId;
     516    pMixInfo->type       = WINMM_MIXER;
     517    if(phmx)
     518        *phmx = (HMIXER)pMixInfo;
     519    return MMSYSERR_NOERROR;
     520}
     521/******************************************************************************/
     522/******************************************************************************/
     523MMRESULT WINAPI mixerClose(HMIXER hmx)
     524{
     525    if(hmx) {
     526        free((void *)hmx);
     527    }
     528    return MMSYSERR_NOERROR;
     529}
     530/******************************************************************************/
     531/******************************************************************************/
     532
     533

  • trunk/src/winmm/mmio.cpp

    r6375 r8470  
    1 /* $Id: mmio.cpp,v 1.8 2001-07-20 15:35:00 sandervl Exp $ */
     1/* $Id: mmio.cpp,v 1.9 2002-05-22 15:50:25 sandervl Exp $ */
    22/*
    33 * MMIO functions
    … …  
    2828#include "dbglocal.h"
    2929
    30 ODINDEBUGCHANNEL(WINMM-MMIO)
    3130
    3231/**************************************************************************
    … …  
    329328 *                              mmioOpenW                       [WINMM.123]
    330329 */
    331 ODINFUNCTION3(HMMIO, mmioOpenW,
    332               LPWSTR,szFileName,
    333               LPMMIOINFO,lpmmioinfo,
    334               DWORD,dwOpenFlags)
     330HMMIO WINAPI mmioOpenW(LPWSTR szFileName, LPMMIOINFO lpmmioinfo, DWORD dwOpenFlags)
    335331{
    336332        LPSTR   szFn = HEAP_strdupWtoA(GetProcessHeap(),0,szFileName);
    … …  
    344340 *                              mmioOpenA                       [WINMM.122]
    345341 */
    346 ODINFUNCTION3(HMMIO, mmioOpenA,
    347               LPSTR,szFileName,
    348               LPMMIOINFO,lpmmioinfo,
    349               DWORD,dwOpenFlags)
     342HMMIO WINAPI mmioOpenA(LPSTR szFileName, LPMMIOINFO lpmmioinfo, DWORD dwOpenFlags)
    350343{
    351344        HMMIO   ret;
    … …  
    370363 *                              mmioClose               [WINMM.114]
    371364 */
    372 ODINFUNCTION2(MMRESULT, mmioClose,
    373               HMMIO,hmmio,
    374               UINT,uFlags)
     365MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
    375366{
    376367        LPMMIOINFO lpmminfo;
    … …  
    402393 *                              mmioRead                [WINMM.124]
    403394 */
    404 ODINFUNCTION3(LONG, mmioRead,
    405               HMMIO,hmmio,
    406               HPSTR,pch,
    407               LONG,cch)
     395LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
    408396{
    409397        LONG       count;
    … …  
    461449 *                              mmioWrite               [WINMM.133]
    462450 */
    463 ODINFUNCTION3(LONG, mmioWrite,
    464               HMMIO,hmmio,
    465               HPCSTR,pch,
    466               LONG,cch)
     451LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
    467452{
    468453        LONG       count;
    … …  
    510495 *                              mmioSeek                [MMSYSTEM.1214]
    511496 */
    512 ODINFUNCTION3(LONG, mmioSeek,
    513               HMMIO, hmmio,
    514               LONG,lOffset,
    515               INT,iOrigin)
     497LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
    516498{
    517499        int        offset;
    … …  
    550532 *                              mmioGetInfo             [MMSYSTEM.1215]
    551533 */
    552 ODINFUNCTION3(UINT, mmioGetInfo,
    553               HMMIO,hmmio,
    554               LPMMIOINFO,lpmmioinfo,
    555               UINT,uFlags)
     534UINT WINAPI mmioGetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uFlags)
    556535{
    557536        LPMMIOINFO      lpmminfo;
    … …  
    568547 *                              mmioSetInfo             [WINMM.130]
    569548 */
    570 ODINFUNCTION3(MMRESULT,mmioSetInfo,
    571              HMMIO, hmmio,
    572              const MMIOINFO*,lpmmioinfo,
    573              UINT,uFlags)
     549MMRESULT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO* lpmmioinfo, UINT uFlags)
    574550{
    575551        LPMMIOINFO      lpmminfo;
    … …  
    586562*                               mmioSetBuffer           [WINMM.129]
    587563*/
    588 ODINFUNCTION4(UINT,mmioSetBuffer,
    589               HMMIO,hmmio,
    590               LPSTR,pchBuffer,
    591               LONG,cchBuffer,
    592               UINT,uFlags)
     564UINT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT uFlags)
    593565{
    594566        LPMMIOINFO      lpmminfo;
    … …  
    645617 *                              mmioFlush               [WINMM.117]
    646618 */
    647 ODINFUNCTION2(UINT,mmioFlush,
    648               HMMIO,hmmio,
    649               UINT,uFlags)
     619UINT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags)
    650620{
    651621        LPMMIOINFO      lpmminfo;
    … …  
    688658 *                              mmioAdvance             [WINMM.113]
    689659 */
    690 ODINFUNCTION3(UINT,mmioAdvance,
    691               HMMIO, hmmio,
    692               LPMMIOINFO,lpmmioinfo,
    693               UINT,uFlags)
     660UINT WINAPI mmioAdvance(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uFlags)
    694661{
    695662        LPMMIOINFO      lpmminfo;
    … …  
    720687 *                              mmioStringToFOURCCA     [WINMM.131]
    721688 */
    722 ODINFUNCTION2(FOURCC,mmioStringToFOURCCA,
    723               LPCSTR, sz, UINT, uFlags)
     689FOURCC WINAPI mmioStringToFOURCCA(LPCSTR sz, UINT  uFlags)
    724690{
    725691  return mmioFOURCC(sz[0],sz[1],sz[2],sz[3]);
    … …  
    729695 *                              mmioStringToFOURCCW     [WINMM.132]
    730696 */
    731 ODINFUNCTION2(FOURCC,mmioStringToFOURCCW,
    732               LPCWSTR, sz, UINT, uFlags)
     697FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT  uFlags)
    733698{
    734699        LPSTR   szA = HEAP_strdupWtoA(GetProcessHeap(),0,sz);
    … …  
    758723static struct IOProcList *pIOProcListAnchor = &defaultProcs[0];
    759724
    760 ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcA,
    761               FOURCC,fccIOProc,
    762               LPMMIOPROC,pIOProc,
    763               DWORD,dwFlags)
     725LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
    764726{
    765727        LPMMIOPROC        lpProc = NULL;
    … …  
    840802*                               mmioSendMessage         [MMSYSTEM.1222]
    841803*/
    842 ODINFUNCTION4(LRESULT,mmioSendMessage,
    843               HMMIO,hmmio,
    844               UINT,uMessage,
    845               LPARAM,lParam1,
    846               LPARAM,lParam2)
     804LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, LPARAM lParam2)
    847805{
    848806        LPMMIOINFO lpmminfo;
    … …  
    886844*                               mmioDescend             [MMSYSTEM.1223]
    887845*/
    888 ODINFUNCTION4(UINT,mmioDescend,
    889               HMMIO,hmmio,
    890               LPMMCKINFO,lpck,
    891               const MMCKINFO *,lpckParent,
    892               UINT,uFlags)
     846UINT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, const MMCKINFO *lpckParent, UINT uFlags)
    893847{
    894848        DWORD           dwOldPos;
    … …  
    990944 *                              mmioAscend              [WINMM.113]
    991945 */
    992 ODINFUNCTION3(UINT,mmioAscend,
    993               HMMIO,hmmio,
    994               LPMMCKINFO,lpck,
    995               UINT,uFlags)
     946UINT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
    996947{
    997948//      TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
    … …  
    1024975 *                                      mmioCreateChunk                                 [WINMM.115]
    1025976 */
    1026 ODINFUNCTION3(UINT,mmioCreateChunk,
    1027               HMMIO,hmmio,
    1028               LPMMCKINFO,lpck,
    1029               UINT,uFlags)
     977UINT WINAPI mmioCreateChunk(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
    1030978{
    1031979        DWORD   dwOldPos;
    … …  
    10661014 *                              mmioRenameA                             [WINMM.125]
    10671015 */
    1068 ODINFUNCTION4(UINT,mmioRenameA,
    1069               LPCSTR,szFileName,
    1070               LPCSTR,szNewFileName,
    1071               LPMMIOINFO,lpmmioinfo,
    1072               DWORD,dwRenameFlags)
     1016UINT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, LPMMIOINFO lpmmioinfo,
     1017                        DWORD dwRenameFlags)
    10731018{
    10741019        UINT result;
    … …  
    11121057 *                              mmioRenameW                             [WINMM.126]
    11131058 */
    1114 ODINFUNCTION4(UINT,mmioRenameW,
    1115               LPCWSTR,szFileName,
    1116               LPCWSTR,szNewFileName,
    1117               LPMMIOINFO,lpmmioinfo,
    1118               DWORD,dwRenameFlags)
     1059UINT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName, LPMMIOINFO lpmmioinfo,
     1060                        DWORD dwRenameFlags)
    11191061{
    11201062        LPSTR           szFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szFileName);
    … …  
    11271069}
    11281070
    1129 ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcW,
    1130               FOURCC, fccIOProc,
    1131               LPMMIOPROC, pIOProc,
    1132               DWORD, dwFlags)
     1071LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
    11331072{
    11341073  // TODO: What is difference in mmioInstallIOProcW and mmioInstallIOProcA?

  • trunk/src/winmm/playsound.cpp

    r5364 r8470  
    1 /* $Id: playsound.cpp,v 1.7 2001-03-24 13:23:48 sandervl Exp $ */
     1/* $Id: playsound.cpp,v 1.8 2002-05-22 15:50:25 sandervl Exp $ */
    22
    33/*
    … …  
    2828#define DBG_LOCALLOG    DBG_playsound
    2929#include "dbglocal.h"
    30 
    31 ODINDEBUGCHANNEL(WINMM-PLAYSOUND)
    3230
    3331
    … …  
    318316 *****************************************************************************/
    319317
    320 ODINFUNCTION3(BOOL, PlaySoundA,
    321               LPCSTR, pszSound,
    322               HMODULE, hmod,
    323               DWORD, fdwSound)
     318BOOL WINAPI PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound)
    324319{
    325320    static LPSTR StrDup = NULL;
    … …  
    404399 *****************************************************************************/
    405400
    406 ODINFUNCTION3(BOOL, PlaySoundW,
    407               LPCWSTR, pszSound,
    408               HMODULE, hmod,
    409               DWORD, fdwSound)
     401BOOL WINAPI PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
    410402{
    411403    LPSTR       pszSoundA;
    … …  
    436428 *****************************************************************************/
    437429
    438 ODINFUNCTION2(BOOL, sndPlaySoundA,
    439               LPCSTR, lpszSoundName,
    440               UINT, uFlags)
     430BOOL WINAPI sndPlaySoundA(LPCSTR lpszSoundName, UINT uFlags)
    441431{
    442432    PlaySound_SearchMode = 1;
    … …  
    458448 *****************************************************************************/
    459449
    460 ODINFUNCTION2(BOOL, sndPlaySoundW,
    461               LPCWSTR, lpszSoundName,
    462               UINT, uFlags)
     450BOOL WINAPI sndPlaySoundW(LPCWSTR lpszSoundName, UINT uFlags)
    463451{
    464452    PlaySound_SearchMode = 1;

  • trunk/src/winmm/time.cpp

    r7428 r8470  
    1 /* $Id: time.cpp,v 1.15 2001-11-22 15:40:46 phaller Exp $ */
     1/* $Id: time.cpp,v 1.16 2002-05-22 15:50:26 sandervl Exp $ */
    22
    33/*
    … …  
    2626#include "dbglocal.h"
    2727
    28 ODINDEBUGCHANNEL(WINMM-TIME)
    29 
    3028
    3129/*****************************************************************************
    … …  
    4240
    4341
    44 ODINFUNCTION0(UINT, mmsystemGetVersion)
     42UINT WINAPI mmsystemGetVersion()
    4543{
    4644  //Returned by winmm.dll from NT4, SP6
    … …  
    6058 *****************************************************************************/
    6159
    62 ODINFUNCTION2(MMRESULT,   timeGetDevCaps,
    63               LPTIMECAPS, ptc,
    64               UINT,       cbtc)
     60MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS ptc, UINT cbtc)
    6561{
    6662  dprintf(("WINMM:timeGetDevCaps Not really Implemented\n"));
    … …  
    8985 *****************************************************************************/
    9086
    91 ODINFUNCTION1(MMRESULT, timeBeginPeriod,
    92               UINT,     cMilliseconds)
     87MMRESULT WINAPI timeBeginPeriod(UINT cMilliseconds)
    9388{
    9489  if (TRUE == OS2TimerResolution::enterResolutionScope(cMilliseconds))
    … …  
    111106 *****************************************************************************/
    112107
    113 ODINFUNCTION1(MMRESULT, timeEndPeriod,
    114               UINT,     cMilliseconds)
     108MMRESULT WINAPI timeEndPeriod(UINT cMilliseconds)
    115109{
    116110  if (TRUE == OS2TimerResolution::leaveResolutionScope(cMilliseconds))
    … …  
    136130 *****************************************************************************/
    137131
    138 ODINFUNCTION1(MMRESULT, timeKillEvent,
    139               UINT,     IDEvent)
     132MMRESULT WINAPI timeKillEvent(UINT IDEvent)
    140133{
    141134  OS2Timer *os2timer = NULL;
    … …  
    165158 *****************************************************************************/
    166159
    167 ODINFUNCTION5(MMRESULT,       timeSetEvent,
    168               UINT,           wDelay,
    169               UINT,           wResolution,
    170               LPTIMECALLBACK, lptc,
    171               DWORD,          dwUser,
    172               UINT,           fuEvent)
     160MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResolution,
     161                             LPTIMECALLBACK lptc, DWORD dwUser,
     162                             UINT fuEvent)
    173163{
    174164  OS2Timer *timer;
    … …  
    259249 *****************************************************************************/
    260250
    261 ODINFUNCTION2(MMRESULT, timeGetSystemTime,
    262               LPMMTIME, pTime,
    263               UINT,     cbTime)
     251MMRESULT WINAPI timeGetSystemTime(LPMMTIME pTime, UINT cbTime)
    264252{
    265253  dprintf2(("timeGetSystemTime %x %d", pTime, cbTime));

  • trunk/src/winmm/wavein.cpp

    r7196 r8470  
    1 /* $Id: wavein.cpp,v 1.10 2001-10-24 22:47:42 sandervl Exp $ */
     1/* $Id: wavein.cpp,v 1.11 2002-05-22 15:50:26 sandervl Exp $ */
    22
    33/*
    … …  
    3535
    3636
    37 ODINDEBUGCHANNEL(WINMM-WAVEIN)
    38 
    39 /******************************************************************************/
    40 /******************************************************************************/
    41 ODINFUNCTION6(MMRESULT, waveInOpen,
    42               LPHWAVEIN, phwi,
    43               UINT, uDeviceID,
    44               const LPWAVEFORMATEX, pwfx,
    45               DWORD, dwCallback,
    46               DWORD, dwInstance,
    47               DWORD, fdwOpen)
     37/******************************************************************************/
     38/******************************************************************************/
     39MMRESULT WINAPI waveInOpen(LPHWAVEIN phwi, UINT uDeviceID, const LPWAVEFORMATEX pwfx,
     40                           DWORD  dwCallback, DWORD  dwInstance, DWORD  fdwOpen)
    4841{
    4942  MMRESULT rc;
    … …  
    5649    if(fdwOpen == WAVE_FORMAT_QUERY) {
    5750        if(DartWaveIn::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
    58                                    pwfx->wBitsPerSample) == TRUE) {
    59                 return(MMSYSERR_NOERROR);
     51                                   pwfx->wBitsPerSample) == TRUE)
     52        {
     53             return(MMSYSERR_NOERROR);
    6054        }
    61         else    return(WAVERR_BADFORMAT);
     55        else return(WAVERR_BADFORMAT);
    6256    }
    6357
    … …  
    8074/******************************************************************************/
    8175/******************************************************************************/
    82 ODINFUNCTION1(MMRESULT, waveInClose,
    83               HWAVEIN, hwi)
    84 {
    85   DartWaveIn *dwave = (DartWaveIn *)hwi;
    86 
    87   if(DartWaveIn::find(dwave) == TRUE)
    88   {
     76MMRESULT WINAPI waveInClose(HWAVEIN hwi)
     77{
     78    DartWaveIn *dwave = (DartWaveIn *)hwi;
     79
     80    if(DartWaveIn::find(dwave) == TRUE)
     81    {
    8982        if(dwave->getState() == STATE_RECORDING)
    9083            return(WAVERR_STILLPLAYING);
    … …  
    9285        delete dwave;
    9386        return(MMSYSERR_NOERROR);
    94   }
    95   else  return(MMSYSERR_INVALHANDLE);
    96 }
    97 /******************************************************************************/
    98 /******************************************************************************/
    99 ODINFUNCTION1(MMRESULT, waveInReset,
    100               HWAVEIN, hwi)
    101 {
    102   DartWaveIn *dwave = (DartWaveIn *)hwi;
    103 
    104   if(DartWaveIn::find(dwave) == TRUE)
    105         return(dwave->reset());
    106   else  return(MMSYSERR_INVALHANDLE);
    107 }
    108 /******************************************************************************/
    109 /******************************************************************************/
    110 ODINFUNCTION1(MMRESULT, waveInStart,
    111               HWAVEIN, hwi)
    112 {
    113   DartWaveIn *dwave = (DartWaveIn *)hwi;
    114 
    115   if(DartWaveIn::find(dwave) == TRUE)
     87    }
     88    else return(MMSYSERR_INVALHANDLE);
     89}
     90/******************************************************************************/
     91/******************************************************************************/
     92MMRESULT WINAPI waveInReset(HWAVEIN hwi)
     93{
     94    DartWaveIn *dwave = (DartWaveIn *)hwi;
     95
     96    if(DartWaveIn::find(dwave) == TRUE)
     97         return(dwave->reset());
     98    else return(MMSYSERR_INVALHANDLE);
     99}
     100/******************************************************************************/
     101/******************************************************************************/
     102MMRESULT WINAPI waveInStart(HWAVEIN  hwi)
     103{
     104    DartWaveIn *dwave = (DartWaveIn *)hwi;
     105
     106    if(DartWaveIn::find(dwave) == TRUE)
    116107        return(dwave->start());
    117   else return(MMSYSERR_INVALHANDLE);
    118 }
    119 /******************************************************************************/
    120 /******************************************************************************/
    121 ODINFUNCTION1(MMRESULT, waveInStop,
    122               HWAVEIN, hwi)
    123 {
    124   DartWaveIn *dwave = (DartWaveIn *)hwi;
    125 
    126   if(DartWaveIn::find(dwave) == TRUE)
     108    else return(MMSYSERR_INVALHANDLE);
     109}
     110/******************************************************************************/
     111/******************************************************************************/
     112MMRESULT WINAPI waveInStop(
     113              HWAVEIN  hwi)
     114{
     115    DartWaveIn *dwave = (DartWaveIn *)hwi;
     116
     117    if(DartWaveIn::find(dwave) == TRUE)
    127118        return(dwave->stop());
    128   else  return(MMSYSERR_INVALHANDLE);
    129 }
    130 /******************************************************************************/
    131 /******************************************************************************/
    132 ODINFUNCTION3(MMRESULT, waveInGetPosition,
    133               HWAVEIN, hwi,
    134               LPMMTIME, pmmt,
    135               UINT, cbmmt)
    136 {
    137   DartWaveIn *dwave = (DartWaveIn *)hwi;
    138 
    139   if(pmmt == NULL)
     119    else return(MMSYSERR_INVALHANDLE);
     120}
     121/******************************************************************************/
     122/******************************************************************************/
     123MMRESULT WINAPI waveInGetPosition(HWAVEIN  hwi, LPMMTIME pmmt, UINT cbmmt)
     124{
     125    DartWaveIn *dwave = (DartWaveIn *)hwi;
     126
     127    if(pmmt == NULL)
    140128        return MMSYSERR_INVALPARAM;
    141129
    142   if(DartWaveIn::find(dwave) == TRUE)
    143   {
    144     ULONG position;
     130    if(DartWaveIn::find(dwave) == TRUE)
     131    {
     132        ULONG position;
    145133
    146134        position = dwave->getPosition();
    … …  
    177165        }
    178166        return MMSYSERR_NOERROR;
    179   }
    180   else  return(MMSYSERR_INVALHANDLE);
    181 }
    182 /******************************************************************************/
    183 /******************************************************************************/
    184 ODINFUNCTION3(MMRESULT, waveInAddBuffer,
    185               HWAVEIN, hwi,
    186               LPWAVEHDR, pwh,
    187               UINT, cbwh)
     167    }
     168    else  return(MMSYSERR_INVALHANDLE);
     169}
     170/******************************************************************************/
     171/******************************************************************************/
     172MMRESULT WINAPI waveInAddBuffer(HWAVEIN  hwi, LPWAVEHDR pwh, UINT cbwh)
    188173{
    189174    DartWaveIn *dwave = (DartWaveIn *)hwi;
    … …  
    207192/******************************************************************************/
    208193/******************************************************************************/
    209 ODINFUNCTION3(MMRESULT, waveInPrepareHeader,
    210               HWAVEIN, hwi,
    211               LPWAVEHDR, pwh,
    212               UINT, cbwh)
     194MMRESULT WINAPI waveInPrepareHeader(HWAVEIN  hwi, LPWAVEHDR pwh, UINT  cbwh)
    213195{
    214196    DartWaveIn *dwave = (DartWaveIn *)hwi;
    … …  
    224206        return(MMSYSERR_NOERROR);
    225207    }
    226     else  return(MMSYSERR_INVALHANDLE);
    227 }
    228 /******************************************************************************/
    229 /******************************************************************************/
    230 ODINFUNCTION3(MMRESULT, waveInUnprepareHeader,
    231               HWAVEIN, hwi,
    232               LPWAVEHDR, pwh,
    233               UINT, cbwh)
     208    else return(MMSYSERR_INVALHANDLE);
     209}
     210/******************************************************************************/
     211/******************************************************************************/
     212MMRESULT WINAPI waveInUnprepareHeader(HWAVEIN  hwi, LPWAVEHDR pwh, UINT  cbwh)
    234213{
    235214    DartWaveIn *dwave = (DartWaveIn *)hwi;
    … …  
    248227/******************************************************************************/
    249228/******************************************************************************/
    250 ODINFUNCTION3(MMRESULT, waveInGetDevCapsA,
    251               UINT, uDeviceID,
    252               LPWAVEINCAPSA, pwic,
    253               UINT, cbwic)
     229MMRESULT WINAPI waveInGetDevCapsA(UINT  uDeviceID, LPWAVEINCAPSA pwic, UINT  cbwic)
    254230{
    255231    if(fMMPMAvailable == FALSE) return MMSYSERR_NODRIVER;
    … …  
    279255/******************************************************************************/
    280256/******************************************************************************/
    281 ODINFUNCTION3(MMRESULT, waveInGetDevCapsW,
    282               UINT, uDeviceID,
    283               LPWAVEINCAPSW, pwic,
    284               UINT, cbwic)
     257MMRESULT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic)
    285258{
    286259    if(fMMPMAvailable == FALSE) return MMSYSERR_NODRIVER;
    … …  
    309282/******************************************************************************/
    310283/******************************************************************************/
    311 ODINFUNCTION3(MMRESULT, waveInGetErrorTextA,
    312               MMRESULT, wError,
    313               LPSTR, lpText,
    314               UINT, cchText)
     284MMRESULT WINAPI waveInGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
    315285{
    316286    dprintf(("WINMM:waveInGetErrorTextA(%d)\n", wError ));
    … …  
    328298/******************************************************************************/
    329299/******************************************************************************/
    330 ODINFUNCTION3(MMRESULT, waveInGetErrorTextW,
    331               MMRESULT, wError,
    332               LPWSTR, lpText,
    333               UINT, cchText)
     300MMRESULT WINAPI waveInGetErrorTextW(MMRESULT wError, LPWSTR lpText, UINT cchText)
    334301{
    335302    dprintf(("WINMM:waveInGetErrorTextW(%d) - stub\n", wError ));
    … …  
    347314/******************************************************************************/
    348315/******************************************************************************/
    349 ODINFUNCTION2(MMRESULT, waveInGetID,
    350               HWAVEIN, hwi,
    351               LPUINT, puDeviceID)
     316MMRESULT WINAPI waveInGetID(HWAVEIN hwi, LPUINT puDeviceID)
    352317{
    353318    DartWaveIn *dwave = (DartWaveIn *)hwi;
    … …  
    361326/******************************************************************************/
    362327/******************************************************************************/
    363 ODINFUNCTION0(UINT, waveInGetNumDevs)
     328UINT WINAPI waveInGetNumDevs()
    364329{
    365330    return DartWaveIn::getNumDevices();
    … …  
    367332/******************************************************************************/
    368333/******************************************************************************/
    369 ODINFUNCTION4(MMRESULT, waveInMessage,
    370               HWAVEIN, hwi,
    371               UINT, uMsg,
    372               DWORD, dw1,
    373               DWORD, dw2)
     334MMRESULT WINAPI waveInMessage(HWAVEIN hwi, UINT uMsg, DWORD dw1, DWORD dw2)
    374335{
    375336    dprintf(("WINMM:waveInMessage - stub\n"));

  • trunk/src/winmm/waveout.cpp

    r7196 r8470  
    1 /* $Id: waveout.cpp,v 1.22 2001-10-24 22:47:42 sandervl Exp $ */
     1/* $Id: waveout.cpp,v 1.23 2002-05-22 15:50:26 sandervl Exp $ */
    22//#undef DEBUG
    33/*
    … …  
    3636#include "dbglocal.h"
    3737
    38 ODINDEBUGCHANNEL(WINMM-WAVEOUT)
    39 
    40 
    41 /******************************************************************************/
    42 /******************************************************************************/
    43 
    44 //@@@PH 1999/12/28 this function needs the win32 tib FS selector for callback purposes
    45 //                 therefore, one cannot use ODINFUNCTION macro wrappers! The xxxFS
    46 //                 macro passes in USHORT selFS as first parameter.
    47 ODINFUNCTION6(MMRESULT, waveOutOpen,
    48               LPHWAVEOUT, phwo,
    49               UINT, uDeviceID,
    50               const LPWAVEFORMATEX, pwfx,
    51               DWORD, dwCallback,
    52               DWORD, dwInstance,
    53               DWORD, fdwOpen)
     38
     39/******************************************************************************/
     40/******************************************************************************/
     41MMRESULT WINAPI waveOutOpen(LPHWAVEOUT phwo, UINT uDeviceID, const LPWAVEFORMATEX pwfx,
     42                            DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen)
    5443{
    5544  MMRESULT rc;
    … …  
    9079/******************************************************************************/
    9180/******************************************************************************/
    92 ODINFUNCTION3(MMRESULT, waveOutWrite,
    93               HWAVEOUT, hwo,
    94               LPWAVEHDR, pwh,
    95               UINT, cbwh)
     81MMRESULT WINAPI waveOutWrite(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    9682{
    9783    WaveOut *dwave = (WaveOut *)hwo;
    … …  
    115101/******************************************************************************/
    116102/******************************************************************************/
    117 ODINFUNCTION1(MMRESULT, waveOutReset,
    118               HWAVEOUT, hwaveout)
     103MMRESULT WINAPI waveOutReset(HWAVEOUT hwaveout)
    119104{
    120105  WaveOut *dwave = (WaveOut *)hwaveout;
    … …  
    126111/******************************************************************************/
    127112/******************************************************************************/
    128 ODINFUNCTION1(MMRESULT, waveOutBreakLoop,
    129               HWAVEOUT, hwaveout)
     113MMRESULT WINAPI waveOutBreakLoop(HWAVEOUT hwaveout)
    130114{
    131115    WaveOut *dwave = (WaveOut *)hwaveout;
    … …  
    138122/******************************************************************************/
    139123/******************************************************************************/
    140 ODINFUNCTION1(MMRESULT, waveOutClose,
    141               HWAVEOUT, hwaveout)
     124MMRESULT WINAPI waveOutClose(HWAVEOUT hwaveout)
    142125{
    143126    WaveOut *dwave = (WaveOut *)hwaveout;
    … …  
    155138/******************************************************************************/
    156139/******************************************************************************/
    157 ODINFUNCTION1(MMRESULT, waveOutPause,
    158               HWAVEOUT, hwaveout)
     140MMRESULT WINAPI waveOutPause(HWAVEOUT hwaveout)
    159141{
    160142    WaveOut *dwave = (WaveOut *)hwaveout;
    … …  
    166148/******************************************************************************/
    167149/******************************************************************************/
    168 ODINFUNCTION1(MMRESULT, waveOutRestart,
    169               HWAVEOUT, hwaveout)
     150MMRESULT WINAPI waveOutRestart(HWAVEOUT hwaveout)
    170151{
    171152    WaveOut *dwave = (WaveOut *)hwaveout;
    … …  
    177158/******************************************************************************/
    178159/******************************************************************************/
    179 ODINFUNCTION3(MMRESULT, waveOutPrepareHeader,
    180               HWAVEOUT, hwo,
    181               LPWAVEHDR, pwh,
    182               UINT, cbwh)
     160MMRESULT WINAPI waveOutPrepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    183161{
    184162    WaveOut *dwave = (WaveOut *)hwo;
    … …  
    198176/******************************************************************************/
    199177/******************************************************************************/
    200 ODINFUNCTION3(MMRESULT, waveOutUnprepareHeader,
    201               HWAVEOUT, hwo,
    202               LPWAVEHDR, pwh,
    203               UINT, cbwh)
     178MMRESULT WINAPI waveOutUnprepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    204179{
    205180    WaveOut *dwave = (WaveOut *)hwo;
    … …  
    218193/******************************************************************************/
    219194/******************************************************************************/
    220 ODINFUNCTION3(MMRESULT, waveOutGetPosition,
    221               HWAVEOUT, hwo,
    222               LPMMTIME, pmmt,
    223               UINT, cbmmt)
     195MMRESULT WINAPI waveOutGetPosition(HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt)
    224196{
    225197  WaveOut *dwave = (WaveOut *)hwo;
    … …  
    273245/******************************************************************************/
    274246/******************************************************************************/
    275 ODINFUNCTION3(MMRESULT, waveOutGetDevCapsA,
    276               UINT, uDeviceID,
    277               LPWAVEOUTCAPSA, pwoc,
    278               UINT, cbwoc)
     247MMRESULT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA pwoc, UINT cbwoc)
    279248{
    280249    if(fMMPMAvailable == FALSE) return MMSYSERR_NODRIVER;
    … …  
    305274/******************************************************************************/
    306275/******************************************************************************/
    307 ODINFUNCTION3(MMRESULT, waveOutGetDevCapsW,
    308               UINT, uDeviceID,
    309               LPWAVEOUTCAPSW, pwoc,
    310               UINT, cbwoc)
     276MMRESULT WINAPI waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc)
    311277{
    312278    if(fMMPMAvailable == FALSE) return MMSYSERR_NODRIVER;
    … …  
    336302/******************************************************************************/
    337303/******************************************************************************/
    338 ODINFUNCTION0(UINT, waveOutGetNumDevs)
     304UINT WINAPI waveOutGetNumDevs()
    339305{
    340306  if(fMMPMAvailable == FALSE) return 0;
    … …  
    344310/******************************************************************************/
    345311/******************************************************************************/
    346 ODINFUNCTION3(MMRESULT, waveOutGetErrorTextA,
    347               MMRESULT, wError,
    348               LPSTR, lpText,
    349               UINT, cchText)
     312MMRESULT WINAPI waveOutGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
    350313{
    351314    char * theMsg = getWinmmMsg( wError );
    … …  
    363326/******************************************************************************/
    364327/******************************************************************************/
    365 ODINFUNCTION3(MMRESULT, waveOutGetErrorTextW,
    366               MMRESULT, wError,
    367               LPWSTR, lpText,
    368               UINT, cchText)
     328MMRESULT WINAPI waveOutGetErrorTextW(MMRESULT wError, LPWSTR lpText, UINT cchText)
    369329{
    370330    char * theMsg = getWinmmMsg( wError );
    … …  
    382342/******************************************************************************/
    383343/******************************************************************************/
    384 ODINFUNCTION2(MMRESULT, waveOutGetID,
    385               HWAVEOUT, hwo,
    386               LPUINT, puDeviceID)
     344MMRESULT WINAPI waveOutGetID(HWAVEOUT hwo, LPUINT puDeviceID)
    387345{
    388346    WaveOut *dwave = (WaveOut *)hwo;
    … …  
    396354/******************************************************************************/
    397355/******************************************************************************/
    398 ODINFUNCTION2(MMRESULT, waveOutGetPitch,
    399               HWAVEOUT, hwo,
    400               LPDWORD, pdwPitch)
    401 {
    402   WaveOut *dwave = (WaveOut *)hwo;
    403   if(WaveOut::find(dwave) == TRUE)
     356MMRESULT WINAPI waveOutGetPitch(HWAVEOUT hwo, LPDWORD pdwPitch)
     357{
     358    WaveOut *dwave = (WaveOut *)hwo;
     359    if(WaveOut::find(dwave) == TRUE)
    404360        return MMSYSERR_NOTSUPPORTED;
    405   else  return(MMSYSERR_INVALHANDLE);
    406 }
    407 /******************************************************************************/
    408 /******************************************************************************/
    409 ODINFUNCTION2(MMRESULT, waveOutSetPitch,
    410               HWAVEOUT, hwo,
    411               DWORD, dwPitch)
     361    else return(MMSYSERR_INVALHANDLE);
     362}
     363/******************************************************************************/
     364/******************************************************************************/
     365MMRESULT WINAPI waveOutSetPitch(HWAVEOUT hwo, DWORD dwPitch)
    412366{
    413367    WaveOut *dwave = (WaveOut *)hwo;
    … …  
    418372/******************************************************************************/
    419373/******************************************************************************/
    420 ODINFUNCTION2(MMRESULT, waveOutGetVolume,
    421               HWAVEOUT, hwo,
    422               LPDWORD, pdwVolume)
    423 {
    424   WaveOut *dwave = (WaveOut *)hwo;
    425   if(WaveOut::find(dwave) == TRUE)
    426   {
     374MMRESULT WINAPI waveOutGetVolume(HWAVEOUT hwo, LPDWORD pdwVolume)
     375{
     376    WaveOut *dwave = (WaveOut *)hwo;
     377    if(WaveOut::find(dwave) == TRUE)
     378    {
    427379        if(pdwVolume!=NULL)
    428380            *pdwVolume=dwave->getVolume();
    429381        return MMSYSERR_NOERROR;
    430   }
    431   else
    432       return MMSYSERR_NOERROR;
     382    }
     383    else return MMSYSERR_NOERROR;
    433384//    return(MMSYSERR_INVALHANDLE);
    434385}
    435386/******************************************************************************/
    436387/******************************************************************************/
    437 ODINFUNCTION2(MMRESULT, waveOutSetVolume,
    438               HWAVEOUT, hwo,
    439               DWORD, dwVolume)
    440 {
    441   WaveOut *dwave = (WaveOut *)hwo;
    442   if(WaveOut::find(dwave) == TRUE)
    443   {
    444     return(dwave->setVolume(dwVolume));
    445   }
    446   if(hwo == NULL) {
    447       WaveOut::setDefaultVolume(dwVolume);
    448   }
    449   return MMSYSERR_NOERROR;
     388MMRESULT WINAPI waveOutSetVolume(HWAVEOUT hwo, DWORD dwVolume)
     389{
     390    WaveOut *dwave = (WaveOut *)hwo;
     391    if(WaveOut::find(dwave) == TRUE)
     392    {
     393        return(dwave->setVolume(dwVolume));
     394    }
     395    if(hwo == NULL) {
     396        WaveOut::setDefaultVolume(dwVolume);
     397    }
     398    return MMSYSERR_NOERROR;
    450399//    return(MMSYSERR_INVALHANDLE);
    451400}
    452401/******************************************************************************/
    453402/******************************************************************************/
    454 ODINFUNCTION2(MMRESULT, waveOutGetPlaybackRate,
    455               HWAVEOUT, hwo,
    456               LPDWORD, pdwRate)
    457 {
    458   WaveOut *dwave = (WaveOut *)hwo;
    459   if(WaveOut::find(dwave) == TRUE)
    460   {
     403MMRESULT WINAPI waveOutGetPlaybackRate(HWAVEOUT hwo, LPDWORD pdwRate)
     404{
     405    WaveOut *dwave = (WaveOut *)hwo;
     406
     407    dprintf(("waveOutGetPlaybackRate: NOT IMPLEMENTED!!"));
     408    if(WaveOut::find(dwave) == TRUE)
     409    {
    461410        return MMSYSERR_NOTSUPPORTED;
    462   }
    463   else return(MMSYSERR_INVALHANDLE);
    464 }
    465 /******************************************************************************/
    466 /******************************************************************************/
    467 ODINFUNCTION2(MMRESULT, waveOutSetPlaybackRate,
    468               HWAVEOUT, hwo,
    469               DWORD, dwRate)
    470 {
    471   WaveOut *dwave = (WaveOut *)hwo;
    472   if(WaveOut::find(dwave) == TRUE)
    473   {
     411    }
     412    else return(MMSYSERR_INVALHANDLE);
     413}
     414/******************************************************************************/
     415/******************************************************************************/
     416MMRESULT WINAPI waveOutSetPlaybackRate(HWAVEOUT hwo, DWORD dwRate)
     417{
     418    WaveOut *dwave = (WaveOut *)hwo;
     419   
     420    dprintf(("waveOutSetPlaybackRate: NOT IMPLEMENTED!!"));
     421    if(WaveOut::find(dwave) == TRUE)
     422    {
    474423        return MMSYSERR_NOTSUPPORTED;
    475   }
    476   else  return(MMSYSERR_INVALHANDLE);
    477 }
    478 /******************************************************************************/
    479 /******************************************************************************/
    480 ODINFUNCTION4(MMRESULT, waveOutMessage,
    481               HWAVEOUT, hwo,
    482               UINT, uMsg,
    483               DWORD, dw1,
    484               DWORD, dw2)
    485 {
    486   WaveOut *dwave = (WaveOut *)hwo;
    487   if(WaveOut::find(dwave) == TRUE)
    488   {
    489     return MMSYSERR_NOTSUPPORTED;
    490   }
    491   else
    492     return(MMSYSERR_INVALHANDLE);
    493 }
    494 /******************************************************************************/
    495 /******************************************************************************/
    496 
    497 
     424    }
     425    else return(MMSYSERR_INVALHANDLE);
     426}
     427/******************************************************************************/
     428/******************************************************************************/
     429MMRESULT WINAPI waveOutMessage(HWAVEOUT hwo, UINT uMsg, DWORD dw1, DWORD dw2)
     430{
     431    WaveOut *dwave = (WaveOut *)hwo;
     432
     433    dprintf(("waveOutMessage: NOT IMPLEMENTED!!"));
     434    if(WaveOut::find(dwave) == TRUE)
     435    {
     436        return MMSYSERR_NOTSUPPORTED;
     437    }
     438    else
     439        return(MMSYSERR_INVALHANDLE);
     440}
     441/******************************************************************************/
     442/******************************************************************************/
     443
     444

  • trunk/src/winmm/winmm.mak

    r7196 r8470  
    1 # $Id: winmm.mak,v 1.8 2001-10-24 22:47:43 sandervl Exp $
     1# $Id: winmm.mak,v 1.9 2002-05-22 15:50:26 sandervl Exp $
    22
    33#
    … …  
    1111# Alternate makefile name.
    1212#
     13!if "$(DEBUG)" == "1"
     14DEFFILE    = winmmdbg.def
     15ORGDEFFILE = winmm.def
     16!endif
    1317WRC_PREFIX_RESOURCE=1
     18
    1419MAKEFILE = winmm.mak
    1520
    … …  
    4954$(OBJDIR)\joyos2.obj \
    5055$(OBJDIR)\winmmrsrc.obj \
     56!ifdef DEBUG
     57$(OBJDIR)\dbgwrap.obj \
     58!endif
    5159$(OBJDIR)\dbglocal.obj
    5260
Note: See TracChangeset for help on using the changeset viewer.