Changeset 588 for trunk/src


Ignore:
Timestamp:
Aug 19, 1999, 8:46:54 PM (26 years ago)
Author:
phaller
Message:

Add: added ODINWRAP support for WINMM

Location:
trunk/src/winmm
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/IRTMidi.cpp

    r120 r588  
    1 /* $Id: IRTMidi.cpp,v 1.4 1999-06-19 10:54:47 sandervl Exp $ */
     1/* $Id: IRTMidi.cpp,v 1.5 1999-08-19 18:46:03 phaller Exp $ */
    22
    33/*******************************************************************************
    … …  
    1313*
    1414*******************************************************************************/
     15
     16
     17/****************************************************************************
     18 * Includes                                                                 *
     19 ****************************************************************************/
     20
    1521#define INCL_DOS
    16 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     22#include <os2wrap.h>     //Odin32 OS/2 api wrappers
    1723#include <win32type.h>
    18 
    1924#include "IRTMidi.hpp"
    2025#include <meerror.h>
    … …  
    692697}
    693698
     699

  • trunk/src/winmm/aux.cpp

    r95 r588  
    1 /* $Id: aux.cpp,v 1.3 1999-06-10 16:24:32 phaller Exp $ */
     1/* $Id: aux.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
    14 
     20#include <odinwrap.h>
    1521#include <string.h>
    1622
    … …  
    2127#include "aux.h"
    2228
     29ODINDEBUGCHANNEL(WINMM-AUX)
     30
    2331/******************************************************************************/
    2432/******************************************************************************/
    25 MMRESULT WIN32API auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA pac, UINT cbac)
     33ODINFUNCTION3(MMRESULT, auxGetDevCapsA,
     34              UINT, uDeviceID,
     35              LPAUXCAPSA, pac,
     36              UINT, cbac)
    2637{
    2738  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    4556/******************************************************************************/
    4657/******************************************************************************/
    47 MMRESULT WIN32API auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW pac, UINT cbac)
     58ODINFUNCTION3(MMRESULT, auxGetDevCapsW,
     59              UINT, uDeviceID,
     60              LPAUXCAPSW, pac,
     61              UINT, cbac)
    4862{
    4963  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    6781/******************************************************************************/
    6882/******************************************************************************/
    69 MMRESULT WIN32API auxSetVolume(UINT uDeviceID, DWORD dwVolume)
     83ODINFUNCTION2(MMRESULT, auxSetVolume,
     84              UINT, uDeviceID,
     85              DWORD, dwVolume)
    7086{
    7187  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    8298/******************************************************************************/
    8399/******************************************************************************/
    84 MMRESULT WIN32API auxGetVolume(UINT uDeviceID, LPDWORD pdwVolume)
     100ODINFUNCTION2(MMRESULT, auxGetVolume,
     101              UINT, uDeviceID,
     102              LPDWORD, pdwVolume)
    85103{
    86104  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    97115/******************************************************************************/
    98116/******************************************************************************/
    99 UINT WIN32API auxGetNumDevs(void)
     117ODINFUNCTION0(UINT, auxGetNumDevs)
    100118{
    101   if(auxOS2Open() == FALSE) {
    102         return(0);
    103   }
    104   return 1;
     119  if(auxOS2Open() == FALSE)
     120    return(0);
     121  else
     122    return 1;
    105123}
    106124/******************************************************************************/
    107125/******************************************************************************/
    108 MMRESULT WIN32API auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
     126ODINFUNCTION4(MMRESULT, auxOutMessage,
     127              UINT, uDeviceID,
     128              UINT, uMsg,
     129              DWORD, dwParam1,
     130              DWORD, dwParam2)
    109131{
    110132  if(uDeviceID == AUX_MAPPER) {//AUX mapper
    … …  
    137159/******************************************************************************/
    138160/******************************************************************************/
     161

  • trunk/src/winmm/auxos2.cpp

    r120 r588  
    1 /* $Id: auxos2.cpp,v 1.4 1999-06-19 10:54:47 sandervl Exp $ */
     1/* $Id: auxos2.cpp,v 1.5 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1111 */
    1212
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1318#define  INCL_BASE
    1419#define  INCL_OS2MM
    15 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     20#include <os2wrap.h>    //Odin32 OS/2 api wrappers
    1621#include <os2me.h>
    1722#include <string.h>
    … …  
    100105/******************************************************************************/
    101106/******************************************************************************/
     107

  • trunk/src/winmm/driver.cpp

    r95 r588  
    1 /* $Id: driver.cpp,v 1.3 1999-06-10 16:24:33 phaller Exp $ */
     1/* $Id: driver.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
    14 
     20#include <odinwrap.h>
    1521#include <string.h>
    1622#include <misc.h>
    … …  
    2026#include "os2timer.h"
    2127
    22 
    23 /*****************************************************************************
    24  * Name      : LRESULT WIN32API SendDriverMessage
    25  * Purpose   : Sends the specified message to the installable driver
     28ODINDEBUGCHANNEL(WINMM-DRIVER)
     29
     30
     31/*****************************************************************************
     32 *             Sends the specifiedmessage to the installable driver
    2633 * Parameters: HDRVR hDrvr
    2734 *             UINT  msg
    … …  
    3643 *****************************************************************************/
    3744
    38 LRESULT WIN32API SendDriverMessage(HDRVR hdrvr,
    39                                       UINT msg,
    40                                       LONG lParam1,
    41                                       LONG lParam2)
    42 {
    43   dprintf(("WINMM: SendDriverMessage(%08x,%08x,%08x,%08x) not implemented.\n",
    44            hdrvr,
    45            msg,
    46            lParam1,
    47            lParam2));
    48 
    49   return 0; /* unsuccessful return */
    50 }
    51 
    52 
    53 /*****************************************************************************
    54  * Name      : HDRVR WIN32API OpenDriver
    55  * Purpose   : Opens an instance of an installable driver and initializes
     45ODINFUNCTION4(LRESULT, SendDriverMessage,
     46              HDRVR, hdrvr,
     47              UINT, msg,
     48              LONG, lParam1,
     49              LONG, lParam2)
     50{
     51  dprintf(("WINMM: SendDriverMessage not implemented.\n"));
     52  return 0; /* unsuccessful return */
     53}
     54
     55
     56/*****************************************************************************
     57 *             Opens an instance of an installable driver and initializes
    5658 *             the instance using either the driver's default settings or a
    5759 *             driver-specific value.
    … …  
    6769 *****************************************************************************/
    6870
    69 HDRVR WIN32API OpenDriver(LPCWSTR lpDriverName,
    70                              LPCWSTR lpSectionName,
    71                              LONG    lParam)
    72 {
    73   dprintf(("WINMM: OpenDriver(%s,%s,%08x) not implemented.\n",
    74            lpDriverName,
    75            lpSectionName,
    76            lParam));
    77 
    78   return 0; /* unsuccessful return */
    79 }
    80 
    81 
    82 /*****************************************************************************
    83  * Name      : HDRVR WIN32API OpenDriverA
    84  * Purpose   : Opens an instance of an installable driver and initializes
     71ODINFUNCTION3(HDRVR, OpenDriver,
     72              LPCWSTR, lpDriverName,
     73              LPCWSTR, lpSectionName,
     74              LONG, lParam)
     75{
     76  dprintf(("WINMM: OpenDriver not implemented.\n"));
     77  return 0; /* unsuccessful return */
     78}
     79
     80
     81/*****************************************************************************
     82 *             Opens an instance of an installable driver and initializes
    8583 *             the instance using either the driver's default settings or a
    8684 *             driver-specific value.
    … …  
    9694 *****************************************************************************/
    9795
    98 HDRVR WIN32API OpenDriverA(LPTSTR lpDriverName,
    99                               LPTSTR lpSectionName,
    100                               LONG   lParam)
    101 {
    102   dprintf(("WINMM: OpenDriverA(%s,%s,%08x) not implemented.\n",
    103            lpDriverName,
    104            lpSectionName,
    105            lParam));
    106 
    107   return 0; /* unsuccessful return */
    108 }
    109 
    110 
    111 
    112 /*****************************************************************************
    113  * Name      : HDRVR WIN32API CloseDriver
    114  * Purpose   : Closes an installable driver.
     96ODINFUNCTION3(HDRVR, OpenDriverA,
     97              LPTSTR, lpDriverName,
     98              LPTSTR, lpSectionName,
     99              LONG, lParam)
     100{
     101  dprintf(("WINMM: OpenDriverA not implemented.\n"));
     102  return 0; /* unsuccessful return */
     103}
     104
     105
     106
     107/*****************************************************************************
     108 *             Closes an installable driver.
    115109 * Parameters: HDRVR hDrvr
    116110 *             LONG  lParam1
    … …  
    124118 *****************************************************************************/
    125119
    126 LRESULT WIN32API CloseDriver(HDRVR hDrvr,
    127                                 LONG  lParam1,
    128                                 LONG  lParam2)
    129 {
    130   dprintf(("WINMM: CloseDriver(%08x,%08x,%08x) not implemented.\n",
    131            hDrvr,
    132            lParam1,
    133            lParam2));
    134 
    135   return 0; /* unsuccessful return */
    136 }
    137 
    138 
    139 /*****************************************************************************
    140  * Name      : LRESULT WIN32API DefDriverProc
    141  * Purpose   : Provides default processing for any messages not processed by
     120ODINFUNCTION3(LRESULT, CloseDriver,
     121              HDRVR, hDrvr,
     122              LONG, lParam1,
     123              LONG, lParam2)
     124{
     125  dprintf(("WINMM: CloseDriver not implemented.\n"));
     126  return 0; /* unsuccessful return */
     127}
     128
     129
     130/*****************************************************************************
     131 *             Provides default processing for anymessages not processed by
    142132 *             an installable driver.
    143133 * Parameters: DWORD dwDriverID
    … …  
    154144 *****************************************************************************/
    155145
    156 LRESULT WIN32API DefDriverProc(DWORD dwDriverID,
    157                                   HDRVR hDrvr,
    158                                   UINT  msg,
    159                                   LONG  lParam1,
    160                                   LONG  lParam2)
    161 {
    162   dprintf(("WINMM: DefDriverProc(%08x,%08x,%08x,%08x,%08x) not implemented.\n",
    163            dwDriverID,
    164            hDrvr,
    165            msg,
    166            lParam1,
    167            lParam2));
    168 
    169   return 0; /* unsuccessful return */
    170 }
    171 
    172 
    173 /*****************************************************************************
    174  * Name      : LRESULT WIN32API DriverCallback
    175  * Purpose   : Calls a callback function, sends a message to a window, or
    176  *             unblocks a thread.
     146ODINFUNCTION5(LRESULT, DefDriverProc,
     147              DWORD, dwDriverID,
     148              HDRVR, hDrvr,
     149              UINT, msg,
     150              LONG, lParam1,
     151              LONG, lParam2)
     152{
     153  dprintf(("WINMM: DefDriverProc not implemented.\n"));
     154  return 0; /* unsuccessful return */
     155}
     156
     157
     158/*****************************************************************************
    177159 * Parameters: DWORD dwCallback
    178160 *             DWORD dwFlags
    … …  
    190172 *****************************************************************************/
    191173
    192 LRESULT WIN32API DriverCallback(DWORD dwCallback,
    193                                    DWORD dwFlags,
    194                                    HDRVR hDrvr,
    195                                    DWORD msg,
    196                                    DWORD dwUser,
    197                                    DWORD dwParam1,
    198                                    DWORD dwParam2)
    199 {
    200   dprintf(("WINMM: DriverCallback(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented.\n",
    201            dwCallback,
    202            dwFlags,
    203            hDrvr,
    204            msg,
    205            dwUser,
    206            dwParam1,
    207            dwParam2));
    208 
     174ODINFUNCTION7(LRESULT, DriverCallback,
     175              DWORD, dwCallback,
     176              DWORD, dwFlags,
     177              HDRVR, hDrvr,
     178              DWORD, msg,
     179              DWORD, dwUser,
     180              DWORD, dwParam1,
     181              DWORD, dwParam2)
     182{
     183  dprintf(("WINMM: DriverCallback not implemented.\n"));
    209184  return FALSE; /* unsuccessful return */
    210185}
    … …  
    212187
    213188/*****************************************************************************
    214  * Name      : HMODULE WIN32API DrvGetModuleHandle
    215189 * Purpose   : Retrieves the instance handle of the module that contains the
    216190 *             installable driver.
    … …  
    224198 *****************************************************************************/
    225199
    226 HMODULE WIN32API DrvGetModuleHandle(HDRVR hDriver)
    227 {
    228   dprintf(("WINMM: DrvGetModuleHandle(%08x) not implemented.\n",
    229            hDriver));
    230 
    231   return 0; /* unsuccessful return */
    232 }
    233 
    234 
    235 /*****************************************************************************
    236  * Name      : LRESULT WIN32API DrvSendMessage
    237  * Purpose   : Sends the specified message to the installable driver
     200ODINFUNCTION1(HMODULE, DrvGetModuleHandle,
     201              HDRVR, hDriver)
     202{
     203  dprintf(("WINMM: DrvGetModuleHandle not implemented.\n"));
     204  return 0; /* unsuccessful return */
     205}
     206
     207
     208/*****************************************************************************
     209 *             Sends the specified message to the installable driver
    238210 * Parameters: HDRVR hDrvr
    239211 *             UINT  msg
    … …  
    248220 *****************************************************************************/
    249221
    250 LRESULT WIN32API DrvSendMessage(HDRVR hdrvr,
    251                                    UINT msg,
    252                                    LONG lParam1,
    253                                    LONG lParam2)
    254 {
    255   dprintf(("WINMM: DrvSendMessage(%08x,%08x,%08x,%08x) not implemented.\n",
    256            hdrvr,
    257            msg,
    258            lParam1,
    259            lParam2));
    260 
    261   return 0; /* unsuccessful return */
    262 }
    263 
    264 
    265 /*****************************************************************************
    266  * Name      : HMODULE WIN32API GetDriverModuleHandle
    267  * Purpose   : Retrieves the instance handle of the module that contains the
     222ODINFUNCTION4(LRESULT, DrvSendMessage,
     223              HDRVR, hdrvr,
     224              UINT, msg,
     225              LONG, lParam1,
     226              LONG, lParam2)
     227{
     228  dprintf(("WINMM: DrvSendMessage not implemented.\n"));
     229  return 0; /* unsuccessful return */
     230}
     231
     232
     233/*****************************************************************************
     234 *             Retrieves the instance handle of the module that contains the
    268235 *             installable driver.
    269236 * Parameters: HDRVR hDriver
    … …  
    276243 *****************************************************************************/
    277244
    278 HMODULE WIN32API GetDriverModuleHandle(HDRVR hDriver)
    279 {
    280   dprintf(("WINMM: GetDriverModuleHandle(%08x) not implemented.\n",
    281            hDriver));
    282 
    283   return 0; /* unsuccessful return */
    284 }
     245ODINFUNCTION1(HMODULE, GetDriverModuleHandle,
     246              HDRVR, hDriver)
     247{
     248  dprintf(("WINMM: GetDriverModuleHandle not implemented.\n"));
     249  return 0; /* unsuccessful return */
     250}
     251

  • trunk/src/winmm/dwaveout.cpp

    r120 r588  
    1 /* $Id: dwaveout.cpp,v 1.4 1999-06-19 10:54:47 sandervl Exp $ */
     1/* $Id: dwaveout.cpp,v 1.5 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1111 */
    1212
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1318#define  INCL_BASE
    1419#define  INCL_OS2MM
    15 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     20#include <os2wrap.h>   //Odin32 OS/2 api wrappers
    1621#include <os2me.h>
    1722#include <stdlib.h>
    … …  
    658663/******************************************************************************/
    659664DartWaveOut *DartWaveOut::waveout = NULL;
     665

  • trunk/src/winmm/joy.cpp

    r249 r588  
    1 /* $Id: joy.cpp,v 1.5 1999-06-30 11:29:40 sandervl Exp $ */
     1/* $Id: joy.cpp,v 1.6 1999-08-19 18:46:04 phaller Exp $ */
    22/*
    33 * Odin Joystick apis
    … …  
    99 *
    1010 */
     11
     12/****************************************************************************
     13 * Includes                                                                 *
     14 ****************************************************************************/
     15
    1116#include <os2win.h>
    1217#include <mmsystem.h>
     18#include <odinwrap.h>
    1319#include <misc.h>
    1420#include <string.h>
    … …  
    2026#include "joyos2.h"
    2127
     28ODINDEBUGCHANNEL(WINMM-JOY)
     29
     30
    2231#define MAXJOYDRIVERS 2
    2332
    … …  
    8392
    8493/*****************************************************************************
    85  * Name      : UINT WIN32API joyGetNumDevs
    86  * Purpose   : Get number of installed joysticks
     94ODINFUNCTION0(*, :
     95ODINFUNCTION0(INT, joyGetNumDevs* Purpose   : Get number of installed joysticks
    8796 * Status    : Done
    8897 *
    8998 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 10:00]
    9099 *****************************************************************************/
    91 UINT WIN32API joyGetNumDevs()
     100ODINFUNCTION0(UINT, joyGetNumDevs)
    92101{
    93102  HANDLE            hJoy;
    … …  
    120129
    121130/*****************************************************************************
    122  * Name      : UINT WIN32API joyGetDevCapsW
    123  * Purpose   : Get Joystick capatibities (Unicode)
     131ODINFUNCTION1(*, :,
     132ODINFUNCTION1(UINT,, *,
     133              Purpose, :Get Joystick capatibities (Unicode)
    124134 * Status    : Done
    125135 *
    126136 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:40]
    127137 *****************************************************************************/
    128 MMRESULT WIN32API joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps,UINT wSize)
    129 {
    130     dprintf(("WINMM:joyGetDevCapsW = %d %X %d\n",wID, lpCaps, wSize));
    131 
     138ODINFUNCTION3(MMRESULT, joyGetDevCapsW,
     139              UINT, wID,
     140              LPJOYCAPSW, lpCaps,
     141              UINT, wSize)
     142{
    132143    if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    133144
    … …  
    167178
    168179/*****************************************************************************
    169  * Name      : UINT WIN32API joyGetDevCapsW
    170  * Purpose   : Get Joystick capatibities (Unicode)
     180ODINFUNCTION1(*, :,
     181ODINFUNCTION1(UINT,, *,
     182              Purpose, :Get Joystick capatibities (Unicode)
    171183 * Status    : Done
    172184 *
    173185 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    174186 *****************************************************************************/
    175 MMRESULT WIN32API joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps,UINT wSize)
    176 {
    177     dprintf(("WINMM:joyGetDevCapsA = %d %X %d\n",wID, lpCaps, wSize));
    178 
     187ODINFUNCTION3(MMRESULT, joyGetDevCapsA,
     188              UINT, wID,
     189              LPJOYCAPSA, lpCaps,
     190              UINT, wSize)
     191{
    179192    if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    180193
    … …  
    213226
    214227/*****************************************************************************
    215  * Name      : MMRESULT WIN32API joyGetPosEx
    216  * Purpose   : Get the extended actual joystick position
     228ODINFUNCTION1(*, :,
     229ODINFUNCTION1(MMRESULT,, *,
     230              Purpose, :Get the extended actual joystick position
    217231 * Status    : Done (but not all functions are functionally but Quake2
    218232 *             running with this function)
    … …  
    220234 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 23:42]
    221235 *****************************************************************************/
    222 MMRESULT WIN32API joyGetPosEx(UINT uJoyID, LPJOYINFOEX pji)
     236ODINFUNCTION2(MMRESULT, joyGetPosEx,
     237              UINT, uJoyID,
     238              LPJOYINFOEX, pji)
    223239{
    224240  JOYINFO            ji;
    … …  
    227243  DWORD              rc;
    228244
    229   dprintf(("WINMM:joyGetPosEx %d %X",uJoyID, pji));
    230 
    231245  if (uJoyID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    232246
    … …  
    237251  rc=JoyOpen(&hGamePort);
    238252
    239   if (rc) return (MMSYSERR_NODRIVER); 
     253  if (rc) return (MMSYSERR_NODRIVER);
    240254
    241255  JoyGetPos(hGamePort,uJoyID,&ji);
    … …  
    304318
    305319/*****************************************************************************
    306  * Name      : MMRESULT WIN32API joyGetPos
    307  * Purpose   : Get the actual joystick position
    308  * Status    : Done
    309  *
    310  * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    311  *****************************************************************************/
    312 MMRESULT WIN32API joyGetPos(UINT uJoyID, LPJOYINFO pji)
     320ODINFUNCTION2(*, :,
     321ODINFUNCTION6(MMRESULT,, joyGetPos,
     322              *,, Purpose:,
     323              Get, the,
     324              actual, joystick,
     325              position *, Status,
     326              :, Done,
     327              * *, Author: Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
     328 *****************************************************************************/
     329ODINFUNCTION2(MMRESULT, joyGetPos,
     330              UINT, uJoyID,
     331              LPJOYINFO, pji)
    313332{
    314333  HANDLE   hGame;
    315334  MMRESULT rc;
    316   dprintf(("WINMM:joyGetPos %d %X\n",uJoyID, pji));
    317 
    318335  if (uJoyID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    319336
    … …  
    331348}
    332349/*****************************************************************************
    333  * Name      : MMRESULT WIN32API joyGetThreshold
    334  * Status    : Done
    335  *
    336  * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    337  *****************************************************************************/
    338 MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
     350ODINFUNCTION2(*, :,
     351ODINFUNCTION2(MMRESULT,, joyGetThreshold,
     352              *,, Status:,
     353              Done *, *Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
     354 *****************************************************************************/
     355ODINFUNCTION2(MMRESULT, joyGetThreshold,
     356              UINT, wID,
     357              LPUINT, lpThreshold)
    339358{
    340359    dprintf(("WINMM:joyGetThreshold %d %X\n",wID, lpThreshold));
    … …  
    348367
    349368/*****************************************************************************
    350  * Name      : MMRESULT WIN32API joySetThreshold
    351  * Status    : Done
    352  *
    353  * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    354  *****************************************************************************/
    355 MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
    356 {
    357    dprintf(("WINMM:joySetThreshold %d %d\n",wID, wThreshold));
    358 
     369ODINFUNCTION2(*, :,
     370ODINFUNCTION2(MMRESULT,, joySetThreshold,
     371              *,, Status:,
     372              Done *, *Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
     373 *****************************************************************************/
     374ODINFUNCTION2(MMRESULT, joySetThreshold,
     375              UINT, wID,
     376              UINT, wThreshold)
     377{
    359378   if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    360379
    … …  
    374393
    375394/*****************************************************************************
    376  * Name      : MMRESULT WIN32API joySetCapture
    377  * Purpose   : Start joystick moves capturing
    378  * Status    : Done
     395ODINFUNCTION4(*, :,
     396ODINFUNCTION4(MMRESULT,, joySetCapture,
     397              *,, Purpose,
     398              :,, Start,
     399              joystick,, movescapturing,
     400              *, Status: Done
    379401 *
    380402 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    381403 *****************************************************************************/
    382 MMRESULT WINAPI joySetCapture(HWND hWnd,UINT wID,UINT wPeriod,BOOL bChanged)
     404ODINFUNCTION4(MMRESULT, joySetCapture,
     405              HWND, hWnd,
     406              UINT, wID,
     407              UINT, wPeriod,
     408              BOOL, bChanged)
    383409{
    384410   JOYTHREADOPT *newthr;
    385411   INT          iThreadId;
    386412   DWORD        rc;
    387 
    388    dprintf(("WINMM:joySetCapture %x %d %d %d\n", hWnd, wID, wPeriod, bChanged));
    389413
    390414   if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    … …  
    412436
    413437/*****************************************************************************
    414  * Name      : MMRESULT WIN32API joyReleaseCapture
    415  * Purpose   : Stop capturing joystick moves
     438ODINFUNCTION1(*, :,
     439ODINFUNCTION1(MMRESULT,, *,
     440              Purpose, :Stop capturing joystick moves
    416441 * Status    : Done (but must be rewriting)
    417442 *
    418443 * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    419444 *****************************************************************************/
    420 MMRESULT WINAPI joyReleaseCapture(UINT wID)
     445ODINFUNCTION1(MMRESULT, joyReleaseCapture,
     446              UINT, wID)
    421447{
    422448  // TODO: Semaphores or waiting for thread...
    423   dprintf(("WINMM:joyReleaseCapture %d\n",wID));
    424 
    425449  if (wID >= MAXJOYDRIVERS) return JOYERR_PARMS;
    426450
    … …  
    433457
    434458/*****************************************************************************
    435  * Name      : MMRESULT WIN32API joyConfigChanged
    436  * Status    : Stub but done ;-)
    437  *
    438  * Author    : Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
    439  *****************************************************************************/
    440 MMRESULT WIN32API joyConfigChanged( DWORD dwFlags )
    441 {
    442   dprintf(("WINMM:joyConfigChanged %X\n",dwFlags));
    443 
     459ODINFUNCTION1(*, :,
     460ODINFUNCTION4(MMRESULT,, *,
     461              Status, :,
     462              Stub, but,
     463              done, ;-,
     464              * *, Author)
     465: Przemyslaw Dobrowolski [Tue, 1999/06/29 09:00]
     466 *****************************************************************************/
     467ODINFUNCTION1(MMRESULT, joyConfigChanged,
     468              DWORD, dwFlags)
     469{
    444470  return JOYERR_NOERROR;
    445471}
    … …  
    500526  _endthread();
    501527}
     528

  • trunk/src/winmm/joyos2.cpp

    r249 r588  
    1 /* $Id: joyos2.cpp,v 1.2 1999-06-30 11:29:40 sandervl Exp $ */
     1/* $Id: joyos2.cpp,v 1.3 1999-08-19 18:46:04 phaller Exp $ */
    22/*
    33 * OS/2 Joystick apis
    … …  
    99 *
    1010 */
     11
     12
     13/****************************************************************************
     14 * Includes                                                                 *
     15 ****************************************************************************/
     16
    1117#define  INCL_BASE
    12 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     18#include <os2wrap.h>     //Odin32 OS/2 api wrappers
    1319#include <misc.h>
    1420#include "joyos2.h"
     21
    1522
    1623#define GAMEPDDNAME     "GAME$"
    … …  
    171178}
    172179
     180

  • trunk/src/winmm/mci.cpp

    r95 r588  
    1 /* $Id: mci.cpp,v 1.3 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: mci.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
    14 
     20#include <odinwrap.h>
    1521#include <string.h>
    1622#include <stdio.h>
    … …  
    2127#include "winmm.h"
    2228
    23 BOOL WIN32API mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
     29ODINDEBUGCHANNEL(WINMM-MCI)
     30
     31
     32ODINFUNCTION3(BOOL, mciDriverNotify,
     33              HWND, hwndCallback,
     34              UINT, uDeviceID,
     35              UINT, uStatus)
    2436{
    2537  dprintf(("WINMM:mciDriverNotify - stub\n"));
    … …  
    2739}
    2840
    29 UINT WIN32API mciDriverYield(UINT uDeviceID)
     41ODINFUNCTION1(UINT, mciDriverYield,
     42              UINT, uDeviceID)
    3043{
    3144  dprintf(("WINMM:mciDriverYield - stub\n"));
    … …  
    3346}
    3447
    35 BOOL WIN32API mciExecute(LPCSTR pszCommand)
     48ODINFUNCTION1(BOOL, mciExecute,
     49              LPCSTR, pszCommand)
    3650{
    3751  dprintf(("WINMM:mciExecute(%s) - stub\n", pszCommand));
    … …  
    3953}
    4054
    41 BOOL WIN32API mciFreeCommandResource(UINT uTable)
     55ODINFUNCTION1(BOOL, mciFreeCommandResource,
     56              UINT, uTable)
    4257{
    4358  dprintf(("WINMM:mciFreeCommandResource - stub\n"));
    … …  
    4560}
    4661
    47 HTASK WIN32API mciGetCreatorTask(MCIDEVICEID mciId)
     62ODINFUNCTION1(HTASK, mciGetCreatorTask,
     63              MCIDEVICEID, mciId)
    4864{
    4965  dprintf(("WINMM:mciGetCreatorTask - stub\n"));
    … …  
    5167}
    5268
    53 MCIDEVICEID WIN32API mciGetDeviceIDA(LPCSTR pszDevice)
     69ODINFUNCTION1(MCIDEVICEID, mciGetDeviceIDA,
     70              LPCSTR, pszDevice)
    5471{
    5572  dprintf(("WINMM:mciGetDeviceIDA - stub\n"));
    … …  
    5774}
    5875
    59 MCIDEVICEID WIN32API mciGetDeviceIDW(LPCWSTR pszDevice)
     76ODINFUNCTION1(MCIDEVICEID, mciGetDeviceIDW,
     77              LPCWSTR, pszDevice)
    6078{
    6179  dprintf(("WINMM:mciGetDeviceIDW - stub\n"));
    … …  
    6381}
    6482
    65 MCIDEVICEID WIN32API mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType )
     83ODINFUNCTION2(MCIDEVICEID, mciGetDeviceIDFromElementIDA,
     84              DWORD, dwElementID,
     85              LPCSTR, lpstrType)
    6686{
    6787  dprintf(("WINMM:mciGetDeviceIDFromElementIDA - stub\n"));
    … …  
    6989}
    7090
    71 MCIDEVICEID WIN32API mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType )
     91ODINFUNCTION2(MCIDEVICEID, mciGetDeviceIDFromElementIDW,
     92              DWORD, dwElementID,
     93              LPCWSTR, lpstrType)
    7294{
    7395  dprintf(("WINMM:mciGetDeviceIDFromElementIDW - stub\n"));
    … …  
    7597}
    7698
    77 DWORD WIN32API mciGetDriverData(UINT uDeviceID)
     99ODINFUNCTION1(DWORD, mciGetDriverData,
     100              UINT, uDeviceID)
    78101{
    79102  dprintf(("WINMM:mciGetDriverData - stub\n"));
    … …  
    81104}
    82105
    83 BOOL WIN32API mciGetErrorStringA( MCIERROR mcierr, LPSTR pszText, UINT cchText )
     106ODINFUNCTION3(BOOL, mciGetErrorStringA,
     107              MCIERROR, mcierr,
     108              LPSTR, pszText,
     109              UINT, cchText)
    84110{
    85111  dprintf(("WINMM:mciGetErrorStringA(%d)\n", mcierr ));
    … …  
    96122}
    97123
    98 BOOL WIN32API mciGetErrorStringW( MCIERROR mcierr, LPWSTR pszText, UINT cchText )
     124ODINFUNCTION3(BOOL, mciGetErrorStringW,
     125              MCIERROR, mcierr,
     126              LPWSTR, pszText,
     127              UINT, cchText)
    99128{
    100129  dprintf(("WINMM:mciGetErrorStringW(%d)\n", mcierr ));
    … …  
    111140}
    112141
    113 YIELDPROC WIN32API mciGetYieldProc(MCIDEVICEID mciId, LPDWORD pdwYieldData)
     142ODINFUNCTION2(YIELDPROC, mciGetYieldProc,
     143              MCIDEVICEID, mciId,
     144              LPDWORD, pdwYieldData)
    114145{
    115146  dprintf(("WINMM:mciGetYieldProc - stub\n"));
    … …  
    117148}
    118149
    119 UINT WIN32API mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName, UINT uType)
     150ODINFUNCTION3(UINT, mciLoadCommandResource,
     151              HINSTANCE, hInstance,
     152              LPCWSTR, lpResName,
     153              UINT, uType)
    120154{
    121155  dprintf(("WINMM:mciLoadCOmmandResource - stub\n"));
    … …  
    123157}
    124158
    125 MCIERROR WIN32API mciSendCommandA(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
     159ODINFUNCTION4(MCIERROR, mciSendCommandA,
     160              MCIDEVICEID, mciId,
     161              UINT, uMsg,
     162              DWORD, dwParam1,
     163              DWORD, dwParam2)
    126164{
    127165  dprintf(("WINMM:mciSendCommandA - stub %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
    … …  
    129167}
    130168
    131 MCIERROR WIN32API mciSendCommandW(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
     169ODINFUNCTION4(MCIERROR, mciSendCommandW,
     170              MCIDEVICEID, mciId,
     171              UINT, uMsg,
     172              DWORD, dwParam1,
     173              DWORD, dwParam2)
    132174{
    133175  dprintf(("WINMM:mciSendCommandW - stub %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
    … …  
    135177}
    136178
    137 MCIERROR WIN32API mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback)
     179ODINFUNCTION4(MCIERROR, mciSendStringA,
     180              LPCSTR, lpstrCommand,
     181              LPSTR, lpstrReturnString,
     182              UINT, uReturnLength,
     183              HWND, hwndCallback)
    138184{
    139185  dprintf(("WINMM:mciSendStringA - stub\n"));
    … …  
    141187}
    142188
    143 MCIERROR WIN32API mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback)
     189ODINFUNCTION4(MCIERROR, mciSendStringW,
     190              LPCWSTR, lpstrCommand,
     191              LPWSTR, lpstrReturnString,
     192              UINT, uReturnLength,
     193              HWND, hwndCallback)
    144194{
    145195  dprintf(("WINMM:mciSendStringW - stub\n"));
    … …  
    147197}
    148198
    149 BOOL WIN32API mciSetDriverData(UINT uDeviceID, DWORD dwData)
     199ODINFUNCTION2(BOOL, mciSetDriverData,
     200              UINT, uDeviceID,
     201              DWORD, dwData)
    150202{
    151203  dprintf(("WINMM:mciSetDriverData - stub\n"));
    … …  
    153205}
    154206
    155 BOOL WIN32API mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData)
     207ODINFUNCTION3(BOOL, mciSetYieldProc,
     208              MCIDEVICEID, mciId,
     209              YIELDPROC, fpYieldProc,
     210              DWORD, dwYieldData)
    156211{
    157212  dprintf(("WINMM:mciSetYieldProc - stub\n"));
    … …  
    159214}
    160215
     216

  • trunk/src/winmm/midi.cpp

    r95 r588  
    1 /* $Id: midi.cpp,v 1.3 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: midi.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
     20#include <odinwrap.h>
    1421#include <process.h>
    1522#include <stdio.h>
    … …  
    1926#include "midi.hpp"
    2027#include <winos2def.h>
     28
     29
     30ODINDEBUGCHANNEL(WINMM-MIDI)
    2131
    2232/*
    … …  
    103113
    104114/******************************************************************************/
    105 MMRESULT WIN32API midiConnect( HMIDI hMidiIn,
    106                                HMIDIOUT hMidiOut,
    107                                LPVOID pReserved )
     115ODINFUNCTION3(MMRESULT, midiConnect,
     116              HMIDI, hMidiIn,
     117              HMIDIOUT, hMidiOut,
     118              LPVOID, pReserved)
    108119{
    109120  // TODO: Implement using instance connections
    … …  
    125136
    126137/******************************************************************************/
    127 MMRESULT WIN32API midiDisconnect( HMIDI hMidiIn,
    128                                   HMIDIOUT hMidiOut,
    129                                   LPVOID pReserved )
     138ODINFUNCTION3(MMRESULT, midiDisconnect,
     139              HMIDI, hMidiIn,
     140              HMIDIOUT, hMidiOut,
     141              LPVOID, pReserved)
    130142{
    131143  // TODO: Implement using instance connections
    … …  
    147159
    148160/******************************************************************************/
    149 MMRESULT WIN32API midiInAddBuffer( HMIDIIN hMidiIn,
    150                                    LPMIDIHDR lpMidiInHdr,
    151                                    UINT cbMidiInHdr )
     161ODINFUNCTION3(MMRESULT, midiInAddBuffer,
     162              HMIDIIN, hMidiIn,
     163              LPMIDIHDR, lpMidiInHdr,
     164              UINT, cbMidiInHdr)
    152165{
    153166  dprintf(("WINMM:midiInAddBuffer -- not Implemented\n" ));
    … …  
    164177
    165178/******************************************************************************/
    166 MMRESULT WIN32API midiInClose( HMIDIIN hMidiIn )
     179ODINFUNCTION1(MMRESULT, midiInClose,
     180              HMIDIIN, hMidiIn)
    167181{
    168182  dprintf(("WINMM:midiInClose -- partially Implemented\n" ));
    … …  
    180194
    181195/******************************************************************************/
    182 MMRESULT WIN32API midiInGetDevCapsA( UINT uDeviceId,      // Device # or handle
    183                                      LPMIDIINCAPSA midiInCaps,    // structure to fill in
    184                                      UINT  sMidiInCaps )  // Length of structure
     196ODINFUNCTION3(MMRESULT, midiInGetDevCapsA,
     197              UINT, uDeviceId,
     198              LPMIDIINCAPSA, midiInCaps,
     199              UINT,  sMidiInCaps)
    185200{
    186201  dprintf(("WINMM:midiInGetDevCapsA(%u)\n", uDeviceId ));
    … …  
    208223
    209224/******************************************************************************/
    210 MMRESULT WIN32API midiInGetDevCapsW( UINT uDeviceId,      // Device # or handle
    211                                      LPMIDIINCAPSW midiInCaps,    // structure to fill in
    212                                      UINT  sMidiInCaps )  // Length of structure
     225ODINFUNCTION3(MMRESULT, midiInGetDevCapsW,
     226              UINT, uDeviceId,
     227              LPMIDIINCAPSW, midiInCaps,
     228              UINT,  sMidiInCaps )
    213229{
    214230  dprintf(("WINMM:midiInGetDevCapsA(%u)\n", uDeviceId ));
    … …  
    237253
    238254/******************************************************************************/
    239 MMRESULT WIN32API midiInGetErrorTextA( MMRESULT wError, LPSTR lpText, UINT cchText )
     255ODINFUNCTION3(MMRESULT, midiInGetErrorTextA,
     256              MMRESULT, wError,
     257              LPSTR, lpText,
     258              UINT, cchText)
    240259{
    241260  dprintf(("WINMM:midiInGetErrorTextA(%d)\n", wError ));
    … …  
    253272
    254273/******************************************************************************/
    255 MMRESULT WIN32API midiInGetErrorTextW( MMRESULT wError, LPWSTR lpText, UINT cchText )
     274ODINFUNCTION3(MMRESULT, midiInGetErrorTextW,
     275              MMRESULT, wError,
     276              LPWSTR, lpText,
     277              UINT, cchText)
    256278{
    257279  dprintf(("WINMM:midiInGetErrorTextW(%d)\n", wError ));
    … …  
    269291
    270292/******************************************************************************/
    271 MMRESULT WIN32API midiInGetID( HMIDIIN hMidiIn, LPUINT puDeviceID )
     293ODINFUNCTION2(MMRESULT, midiInGetID,
     294              HMIDIIN, hMidiIn,
     295              LPUINT, puDeviceID)
    272296{
    273297  dprintf(("WINMM:midiInGetID\n" ));
    … …  
    286310
    287311/******************************************************************************/
    288 UINT WIN32API midiInMessage( HMIDIIN hmi, UINT msg, DWORD dw1, DWORD dw2 )
     312ODINFUNCTION4(UINT, midiInMessage,
     313              HMIDIIN, hmi,
     314              UINT, msg,
     315              DWORD, dw1,
     316              DWORD, dw2)
    289317{
    290318  dprintf(("WINMM:midiInMessage -- not Implemented\n" ));
    … …  
    293321
    294322/******************************************************************************/
    295 UINT WIN32API midiInGetNumDevs( void )
     323ODINFUNCTION0(UINT, midiInGetNumDevs)
    296324{
    297325  UINT i = IRTMIDI->numInInstances();
    298   dprintf(("WINMM:midiInGetNumDevs - returning %u\n", i ));
    299326  return i;
    300327}
    301328
    302329/******************************************************************************/
    303 MMRESULT WIN32API midiInOpen( LPHMIDIIN lphMidiIn,
    304                               UINT uDeviceId,
    305                               DWORD dwCallback,
    306                               DWORD dwCallbackInstance,
    307                               DWORD dwflags )
     330ODINFUNCTION5(MMRESULT, midiInOpen,
     331              LPHMIDIIN, lphMidiIn,
     332              UINT, uDeviceId,
     333              DWORD, dwCallback,
     334              DWORD, dwCallbackInstance,
     335              DWORD, dwflags)
    308336{
    309337  dprintf(("WINMM:midiInOpen(%d) --  partial Implementation\n", uDeviceId ));
    … …  
    326354
    327355/******************************************************************************/
    328 MMRESULT WIN32API midiInPrepareHeader( HMIDIIN hMidiIn,
    329                                        LPMIDIHDR lpMidiInHdr,
    330                                        UINT cbMidiInHdr )
     356ODINFUNCTION3(MMRESULT, midiInPrepareHeader,
     357              HMIDIIN, hMidiIn,
     358              LPMIDIHDR, lpMidiInHdr,
     359              UINT, cbMidiInHdr)
    331360{
    332361  dprintf(("WINMM:midiInPrepareHeader -- not Implemented\n" ));
    … …  
    344373
    345374/******************************************************************************/
    346 MMRESULT WIN32API midiInReset( HMIDIIN hMidiIn )
     375ODINFUNCTION1(MMRESULT, midiInReset,
     376              HMIDIIN, hMidiIn)
    347377{
    348378  dprintf(("WINMM:midiInReset -- not Implemented\n" ));
    … …  
    359389
    360390/******************************************************************************/
    361 MMRESULT WIN32API midiInStart( HMIDIIN hMidiIn )
     391ODINFUNCTION1(MMRESULT, midiInStart,
     392              HMIDIIN, hMidiIn)
    362393{
    363394  dprintf(("WINMM:midiInStart\n" ));
    … …  
    374405
    375406/******************************************************************************/
    376 MMRESULT WIN32API midiInStop( HMIDIIN hMidiIn )
     407ODINFUNCTION1(MMRESULT, midiInStop,
     408              HMIDIIN, hMidiIn)
    377409{
    378410  dprintf(("WINMM:midiInStop\n" ));
    … …  
    389421
    390422/******************************************************************************/
    391 MMRESULT WIN32API midiInUnprepareHeader( HMIDIIN hMidiIn,
    392                                          LPMIDIHDR lpMidiInHdr,
    393                                          UINT cbMidiInHdr )
     423ODINFUNCTION3(MMRESULT, midiInUnprepareHeader,
     424              HMIDIIN, hMidiIn,
     425              LPMIDIHDR, lpMidiInHdr,
     426              UINT, cbMidiInHdr)
    394427{
    395428  dprintf(("WINMM:midiInUnPrepareHeader -- not Implemented\n" ));
    … …  
    406439
    407440/******************************************************************************/
    408 MMRESULT WIN32API midiOutCacheDrumPatches( HMIDIOUT hMidiOut,
    409                                            UINT wPatch,
    410                                            WORD * lpKeyArray,
    411                                            UINT wFlags )
     441ODINFUNCTION4(MMRESULT, midiOutCacheDrumPatches,
     442              HMIDIOUT, hMidiOut,
     443              UINT, wPatch,
     444              WORD *, lpKeyArray,
     445              UINT, wFlags)
    412446{
    413447  // Valid only for an Internal synth.  So we won't do it for now.
    … …  
    425459
    426460/******************************************************************************/
    427 MMRESULT WIN32API midiOutCachePatches( HMIDIOUT hMidiOut,
    428                                        UINT wBank,
    429                                        WORD * lpPatchArray,
    430                                        UINT wFlags )
     461ODINFUNCTION4(MMRESULT, midiOutCachePatches,
     462              HMIDIOUT, hMidiOut,
     463              UINT, wBank,
     464              WORD *, lpPatchArray,
     465              UINT, wFlags)
    431466{
    432467  // Valid only for an Internal synth.  So we won't do it for now.
    … …  
    444479
    445480/******************************************************************************/
    446 MMRESULT WIN32API midiOutClose( HMIDIOUT hMidiOut )
     481ODINFUNCTION1(MMRESULT, midiOutClose,
     482              HMIDIOUT, hMidiOut)
    447483{
    448484  dprintf(("WINMM:midiOutClose - partially implemented\n" ));
    … …  
    461497
    462498/******************************************************************************/
    463 MMRESULT WIN32API midiOutGetDevCapsA( UINT uDeviceId,      // Device # or handle
    464                                       LPMIDIOUTCAPSA midiOutCaps,   // structure to fill in
    465                                       UINT  sMidiOutCaps ) // Length of structure
     499ODINFUNCTION3(MMRESULT, midiOutGetDevCapsA,
     500              UINT, uDeviceId,
     501              LPMIDIOUTCAPSA, midiOutCaps,
     502              UINT,  sMidiOutCaps )
    466503{
    467504  // TODO: Actually fill in the important fields
    … …  
    511548
    512549/******************************************************************************/
    513 MMRESULT WIN32API midiOutGetDevCapsW( UINT uDeviceId,      // Device # or handle
    514                                       LPMIDIOUTCAPSW midiOutCaps,   // structure to fill in
    515                                       UINT  sMidiOutCaps ) // Length of structure
     550ODINFUNCTION3(MMRESULT, midiOutGetDevCapsW,
     551              UINT, uDeviceId,
     552              LPMIDIOUTCAPSW, midiOutCaps,
     553              UINT,  sMidiOutCaps )
    516554{
    517555  // TODO: Actually fill in the important fields
    … …  
    563601
    564602/******************************************************************************/
    565 MMRESULT WIN32API midiOutGetErrorTextA( MMRESULT wError, LPSTR lpText, UINT cchText )
     603ODINFUNCTION3(MMRESULT, midiOutGetErrorTextA,
     604              MMRESULT, wError,
     605              LPSTR, lpText,
     606              UINT, cchText)
    566607{
    567608  dprintf(("WINMM:midiOutGetErrorTextA(%d)\n", wError ));
    … …  
    579620
    580621/******************************************************************************/
    581 MMRESULT WIN32API midiOutGetErrorTextW( MMRESULT wError, LPWSTR lpText, UINT cchText )
     622ODINFUNCTION3(MMRESULT, midiOutGetErrorTextW,
     623              MMRESULT, wError,
     624              LPWSTR, lpText,
     625              UINT, cchText)
    582626{
    583627  dprintf(("WINMM:midiOutGetErrorTextW(%d) - need to translate\n", wError ));
    … …  
    595639
    596640/******************************************************************************/
    597 MMRESULT WIN32API midiOutGetID( HMIDIOUT hMidiOut,
    598                                 LPUINT puDeviceID )
     641ODINFUNCTION2(MMRESULT, midiOutGetID,
     642              HMIDIOUT, hMidiOut,
     643              LPUINT, puDeviceID)
    599644{
    600645  dprintf(("WINMM:midiOutGetID\n" ));
    … …  
    612657
    613658/******************************************************************************/
    614 UINT WIN32API midiOutGetNumDevs( void )
     659ODINFUNCTION0(UINT, midiOutGetNumDevs)
    615660{
    616661  UINT i = IRTMIDI->numOutInstances();
    617   dprintf(("WINMM:midiOutGetNumDevs - returning %u\n", i ));
    618662  return i;
    619663}
    620664
    621665/******************************************************************************/
    622 MMRESULT WIN32API midiOutGetVolume( HMIDIOUT hMidiOut,
    623                                     LPDWORD lpdwVolume )
    624 {
    625   dprintf(("WINMM:midiOutGetVolume\n" ));
     666ODINFUNCTION2(MMRESULT, midiOutGetVolume,
     667              HMIDIOUT, hMidiOut,
     668              LPDWORD, lpdwVolume)
     669{
    626670  MMRESULT rc;
    627671  MidiOut * midiOut = MidiOut::find( hMidiOut );
    … …  
    637681
    638682/******************************************************************************/
    639 MMRESULT WIN32API midiOutLongMsg( HMIDIOUT hMidiOut,
    640                                   LPMIDIHDR lpMidiOutHdr,
    641                                   UINT cbMidiOutHdr )
     683ODINFUNCTION3(MMRESULT, midiOutLongMsg,
     684              HMIDIOUT, hMidiOut,
     685              LPMIDIHDR, lpMidiOutHdr,
     686              UINT, cbMidiOutHdr)
    642687{
    643688  // TODO: Implement this
    … …  
    657702
    658703/******************************************************************************/
    659 UINT WIN32API midiOutMessage( HMIDIOUT hMidiOut,
    660                               UINT msg, DWORD dw1, DWORD dw2 )
     704ODINFUNCTION4(UINT, midiOutMessage,
     705              HMIDIOUT, hMidiOut,
     706              UINT, msg,
     707              DWORD, dw1,
     708              DWORD, dw2)
    661709{
    662710  // TODO: Need to find out wha drivers actually return.
    … …  
    666714
    667715/******************************************************************************/
    668 MMRESULT WIN32API midiOutOpen( LPHMIDIOUT lphMidiOut,
    669                                UINT uDeviceId,
    670                                DWORD dwCallback,
    671                                DWORD dwCallbackInstance,
    672                                DWORD dwflags )
     716ODINFUNCTION5(MMRESULT, midiOutOpen,
     717              LPHMIDIOUT, lphMidiOut,
     718              UINT, uDeviceId,
     719              DWORD, dwCallback,
     720              DWORD, dwCallbackInstance,
     721              DWORD, dwflags)
    673722{
    674723  // TODO: - Handle thread callback, if any program really needs it
    … …  
    706755
    707756/******************************************************************************/
    708 MMRESULT WIN32API midiOutPrepareHeader( HMIDIOUT hMidiOut,
    709                                         LPMIDIHDR lpMidiOutHdr,
    710                                         UINT cbMidiOutHdr )
     757ODINFUNCTION3(MMRESULT, midiOutPrepareHeader,
     758              HMIDIOUT, hMidiOut,
     759              LPMIDIHDR, lpMidiOutHdr,
     760              UINT, cbMidiOutHdr)
    711761{
    712762  // TODO: Either implement or treat as a NOOP as we may not need to "prepare"
    … …  
    725775
    726776/******************************************************************************/
    727 MMRESULT WIN32API midiOutReset( HMIDIOUT hMidiOut )
     777ODINFUNCTION1(MMRESULT, midiOutReset,
     778              HMIDIOUT, hMidiOut)
    728779{
    729780  // TODO: - return pending output buffers to callback
    … …  
    743794
    744795/******************************************************************************/
    745 MMRESULT WIN32API midiOutSetVolume( HMIDIOUT hMidiOut,
    746                                     DWORD dwVolume )
     796ODINFUNCTION2(MMRESULT, midiOutSetVolume,
     797              HMIDIOUT, hMidiOut,
     798              DWORD, dwVolume)
    747799{
    748800  dprintf(("WINMM:midiOutSetVolume\n" ));
    … …  
    760812
    761813/******************************************************************************/
    762 MMRESULT WIN32API midiOutShortMsg( HMIDIOUT hMidiOut,
    763                                    DWORD dwMsg )
     814ODINFUNCTION2(MMRESULT, midiOutShortMsg,
     815              HMIDIOUT, hMidiOut,
     816              DWORD, dwMsg)
    764817{
    765818  dprintf(("WINMM:midiOutShortMsg(%X)\n", dwMsg ));
    … …  
    777830
    778831/******************************************************************************/
    779 MMRESULT WIN32API midiOutUnprepareHeader( HMIDIOUT hMidiOut,
    780                                           LPMIDIHDR lpMidiOutHdr,
    781                                           UINT cbMidiOutHdr )
     832ODINFUNCTION3(MMRESULT, midiOutUnprepareHeader,
     833              HMIDIOUT, hMidiOut,
     834              LPMIDIHDR, lpMidiOutHdr,
     835              UINT, cbMidiOutHdr)
    782836{
    783837  // TODO: - return MIDIERR_STILLPLAYING if buffer is playing
    … …  
    11471201}
    11481202
     1203

  • trunk/src/winmm/midistrm.cpp

    r95 r588  
    1 /* $Id: midistrm.cpp,v 1.3 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: midistrm.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
     20#include <odinwrap.h>
    1421#include "midi.hpp"
    1522#include <process.h>
    … …  
    1825#include <unicode.h>
    1926
     27
     28ODINDEBUGCHANNEL(WINMM-MIDISTRM)
     29
     30
    2031/******************************************************************************/
    21 MMRESULT WIN32API midiStreamClose(HMIDISTRM hms)
     32ODINFUNCTION1(MMRESULT, midiStreamClose,
     33              HMIDISTRM, hms)
    2234{
    2335  dprintf(("WINMM:midiStreamClose - stub\n" ));
    … …  
    2840
    2941/******************************************************************************/
    30 MMRESULT WIN32API midiStreamOpen(LPHMIDISTRM phms,
    31                                  LPUINT puDeviceID,
    32                                  DWORD cMidi,
    33                                  DWORD dwCallback,
    34                                  DWORD dwInstance,
    35                                  DWORD fdwOpen)
     42ODINFUNCTION6(MMRESULT, midiStreamOpen,
     43              LPHMIDISTRM, phms,
     44              LPUINT, puDeviceID,
     45              DWORD, cMidi,
     46              DWORD, dwCallback,
     47              DWORD, dwInstance,
     48              DWORD, fdwOpen)
    3649{
    3750  dprintf(("WINMM:midiStreamOpen - stub\n" ));
    … …  
    4255
    4356/******************************************************************************/
    44 MMRESULT WIN32API midiStreamProperty(HMIDISTRM hms, LPBYTE lppropdata, DWORD dwProperty)
     57ODINFUNCTION3(MMRESULT, midiStreamProperty,
     58              HMIDISTRM, hms,
     59              LPBYTE, lppropdata,
     60              DWORD, dwProperty)
    4561{
    4662  dprintf(("WINMM:midiStreamProperty - stub\n" ));
    … …  
    5167
    5268/******************************************************************************/
    53 MMRESULT WIN32API midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt)
     69ODINFUNCTION3(MMRESULT, midiStreamPosition,
     70              HMIDISTRM, hms,
     71              LPMMTIME, lpmmt,
     72              UINT, cbmmt)
    5473{
    5574  dprintf(("WINMM:midiStreamPosition - stub\n" ));
    … …  
    6079
    6180/******************************************************************************/
    62 MMRESULT WIN32API midiStreamOut(HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh)
     81ODINFUNCTION3(MMRESULT, midiStreamOut,
     82              HMIDISTRM, hms,
     83              LPMIDIHDR, pmh,
     84              UINT, cbmh)
    6385{
    6486  dprintf(("WINMM:midiStreamOut - stub\n" ));
    … …  
    6991
    7092/******************************************************************************/
    71 MMRESULT WIN32API midiStreamPause(HMIDISTRM hms)
     93ODINFUNCTION1(MMRESULT, midiStreamPause,
     94              HMIDISTRM, hms)
    7295{
    7396  dprintf(("WINMM:midiStreamPause - stub\n" ));
    … …  
    78101
    79102/******************************************************************************/
    80 MMRESULT WIN32API midiStreamRestart(HMIDISTRM hms)
     103ODINFUNCTION1(MMRESULT, midiStreamRestart,
     104              HMIDISTRM, hms)
    81105{
    82106  dprintf(("WINMM:midiStreamRestart - stub\n" ));
    … …  
    87111
    88112/******************************************************************************/
    89 MMRESULT WIN32API midiStreamStop(HMIDISTRM hms)
     113ODINFUNCTION1(MMRESULT, midiStreamStop,
     114              HMIDISTRM, hms)
    90115{
    91116  dprintf(("WINMM:midiStreamStop - stub\n" ));
    … …  
    94119  return rc;
    95120}
     121

  • trunk/src/winmm/mixer.cpp

    r95 r588  
    1 /* $Id: mixer.cpp,v 1.3 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: mixer.cpp,v 1.4 1999-08-19 18:46:04 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13/****************************************************************************
     14 * Includes                                                                 *
     15 ****************************************************************************/
     16
    1217#include <os2win.h>
    1318#include <mmsystem.h>
     19#include <odinwrap.h>
    1420#include <misc.h>
     21
     22
     23ODINDEBUGCHANNEL(WINMM-MIXER)
    1524
    1625//
    … …  
    1928
    2029/******************************************************************************/
    21 MMRESULT WIN32API mixerClose( HMIXER hmx )
     30ODINFUNCTION1(MMRESULT, mixerClose,
     31              HMIXER, hmx)
    2232{
    2333  dprintf(("WINMM:mixerClose - stub\n" ));
    … …  
    2636
    2737/******************************************************************************/
    28 MMRESULT WIN32API mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
     38ODINFUNCTION3(MMRESULT, mixerGetControlDetailsA,
     39              HMIXEROBJ, hmxobj,
     40              LPMIXERCONTROLDETAILS, pmxcd,
     41              DWORD, fdwDetails)
    2942{
    3043  dprintf(("WINMM:mixerGetControlDetailsA - stub\n" ));
    … …  
    3346
    3447/******************************************************************************/
    35 MMRESULT WIN32API mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
     48ODINFUNCTION3(MMRESULT, mixerGetControlDetailsW,
     49              HMIXEROBJ, hmxobj,
     50              LPMIXERCONTROLDETAILS, pmxcd,
     51              DWORD, fdwDetails)
    3652{
    3753  dprintf(("WINMM:mixerGetControlDetailsW - stub\n" ));
    … …  
    4056
    4157/******************************************************************************/
    42 MMRESULT WIN32API mixerGetDevCapsA( UINT uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps)
     58ODINFUNCTION3(MMRESULT, mixerGetDevCapsA,
     59              UINT, uMxId,
     60              LPMIXERCAPSA, pmxcaps,
     61              UINT, cbmxcaps)
    4362{
    4463  dprintf(("WINMM:mixerGetDevCapsA(%d) -stub\n", uMxId ));
    … …  
    4766
    4867/******************************************************************************/
    49 MMRESULT WIN32API mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls)
     68ODINFUNCTION3(MMRESULT, mixerGetLineControlsA,
     69              HMIXEROBJ, hmxobj,
     70              LPMIXERLINECONTROLSA, pmxlc,
     71              DWORD, fdwControls)
    5072{
    5173  dprintf(("WINMM:mixerGetGetLineControlsA - stub\n" ));
    … …  
    5476
    5577/******************************************************************************/
    56 MMRESULT WIN32API mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls)
     78ODINFUNCTION3(MMRESULT, mixerGetLineControlsW,
     79              HMIXEROBJ, hmxobj,
     80              LPMIXERLINECONTROLSW, pmxlc,
     81              DWORD, fdwControls)
    5782{
    5883  dprintf(("WINMM:mixerGetGetLineControlsW - stub\n" ));
    … …  
    6186
    6287/******************************************************************************/
    63 MMRESULT WIN32API mixerGetDevCapsW( UINT uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps)
     88ODINFUNCTION3(MMRESULT, mixerGetDevCapsW,
     89              UINT, uMxId,
     90              LPMIXERCAPSW, pmxcaps,
     91              UINT, cbmxcaps)
    6492{
    6593  dprintf(("WINMM:mixerGetDevCapsW(%u) - stub\n", uMxId ));
    … …  
    6896
    6997/******************************************************************************/
    70 MMRESULT WIN32API mixerGetID( HMIXEROBJ hmxobj, UINT *puMxId, DWORD fdwId)
     98ODINFUNCTION3(MMRESULT, mixerGetID,
     99              HMIXEROBJ, hmxobj,
     100              UINT *, puMxId,
     101              DWORD, fdwId)
    71102{
    72103  dprintf(("WINMM:mixerGetID - stub\n" ));
    … …  
    75106
    76107/******************************************************************************/
    77 MMRESULT WIN32API mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo)
     108ODINFUNCTION3(MMRESULT, mixerGetLineInfoA,
     109              HMIXEROBJ, hmxobj,
     110              LPMIXERLINEA, pmxl,
     111              DWORD, fdwInfo)
    78112{
    79113  dprintf(("WINMM:mixerGetLineInfoA - stub\n" ));
    … …  
    82116
    83117/******************************************************************************/
    84 MMRESULT WIN32API mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo)
     118ODINFUNCTION3(MMRESULT, mixerGetLineInfoW,
     119              HMIXEROBJ, hmxobj,
     120              LPMIXERLINEW, pmxl,
     121              DWORD, fdwInfo)
    85122{
    86123  dprintf(("WINMM:mixerGetLineInfoW - stub\n" ));
    … …  
    89126
    90127/******************************************************************************/
    91 MMRESULT WIN32API mixerMessage( HMIXER hmx, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
     128ODINFUNCTION4(MMRESULT, mixerMessage,
     129              HMIXER, hmx,
     130              UINT, uMsg,
     131              DWORD, dwParam1,
     132              DWORD, dwParam2)
    92133{
    93134  dprintf(("WINMM:mixerMessage - stub\n" ));
    … …  
    96137
    97138/******************************************************************************/
    98 UINT WIN32API mixerGetNumDevs( void )
     139ODINFUNCTION0(UINT, mixerGetNumDevs)
    99140{
    100141  dprintf(("WINMM:mixerGetNumDevs - returning 0\n"));
    … …  
    103144
    104145/******************************************************************************/
    105 MMRESULT WIN32API mixerOpen( LPHMIXER phmx, UINT uMxId, DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen)
     146ODINFUNCTION5(MMRESULT, mixerOpen,
     147              LPHMIXER, phmx,
     148              UINT, uMxId,
     149              DWORD, dwCallback,
     150              DWORD, dwInstance,
     151              DWORD, fdwOpen)
    106152{
    107153  dprintf(("WINMM:mixerOpen(%d) - stub\n", uMxId ));
    … …  
    109155}
    110156
    111 MMRESULT WIN32API mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails)
     157ODINFUNCTION3(MMRESULT, mixerSetControlDetails,
     158              HMIXEROBJ, hmxobj,
     159              LPMIXERCONTROLDETAILS, pmxcd,
     160              DWORD, fdwDetails)
    112161{
    113162  dprintf(("WINMM:mixerSetControlDetails - stub\n" ));
    … …  
    115164}
    116165
     166

  • trunk/src/winmm/mmio.cpp

    r95 r588  
    1 /* $Id: mmio.cpp,v 1.3 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: mmio.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
    14 
     20#include <odinwrap.h>
    1521#include <string.h>
    1622#include <misc.h>
    … …  
    2026
    2127
    22 MMRESULT WIN32API mmioAdvance(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT fuOperation)
     28ODINDEBUGCHANNEL(WINMM-MMIO)
     29
     30
     31ODINFUNCTION3(MMRESULT, mmioAdvance,
     32              HMMIO, hmmio,
     33              LPMMIOINFO, lpmmioinfo,
     34              UINT, fuOperation)
    2335{
    2436  dprintf(("WINMM:mmioAdvance - stub\n"));
    … …  
    2638}
    2739
    28 MMRESULT WIN32API mmioAscend(HMMIO hmmio, LPMMCKINFO lpmmcki, UINT uReserved)
     40ODINFUNCTION3(MMRESULT, mmioAscend,
     41              HMMIO, hmmio,
     42              LPMMCKINFO, lpmmcki,
     43              UINT, uReserved)
    2944{
    3045  dprintf(("WINMM:mmioAscend - stub\n"));
    … …  
    3247}
    3348
    34 MMRESULT WIN32API mmioClose(HMMIO hmmio, UINT fuOption)
     49ODINFUNCTION2(MMRESULT, mmioClose,
     50              HMMIO, hmmio,
     51              UINT, fuOption)
    3552{
    3653  dprintf(("WINMM:mmioClose - stub\n"));
    … …  
    4360//UINT fuOptions;       /* chunk creation options       */
    4461/******************************************************************************/
    45 MMRESULT WIN32API mmioCreateChunk(HMMIO hmmio, LPMMCKINFO lpmmcki, UINT fuOptions)
     62ODINFUNCTION3(MMRESULT, mmioCreateChunk,
     63              HMMIO, hmmio,
     64              LPMMCKINFO, lpmmcki,
     65              UINT, fuOptions)
    4666{
    4767    dprintf(("WINMM:mmioCreateChunk - stub\n"));
    … …  
    5575//UINT fuSearch;        /* search-option flags  */
    5676/******************************************************************************/
    57 MMRESULT WIN32API mmioDescend(HMMIO hmmio, LPMMCKINFO lpmmcki,
    58                               const MMCKINFO *lpmmckiParent, UINT fuSearch)
     77ODINFUNCTION4(MMRESULT, mmioDescend,
     78              HMMIO, hmmio,
     79              LPMMCKINFO, lpmmcki,
     80              const MMCKINFO *, lpmmckiParent,
     81              UINT, fuSearch)
    5982{
    6083    dprintf(("WINMM:mmioDescend - stub\n"));
    … …  
    6285}
    6386
    64 MMRESULT WIN32API mmioFlush(HMMIO hmmio, UINT fuFlush)
     87ODINFUNCTION2(MMRESULT, mmioFlush,
     88              HMMIO, hmmio,
     89              UINT, fuFlush)
    6590{
    6691  dprintf(("WINMM:mmioFlush - stub\n"));
    … …  
    6893}
    6994
    70 MMRESULT WIN32API mmioGetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uReserved)
     95ODINFUNCTION3(MMRESULT, mmioGetInfo,
     96              HMMIO, hmmio,
     97              LPMMIOINFO, lpmmioinfo,
     98              UINT, uReserved)
    7199{
    72100  dprintf(("WINMM:mmioGetInfo - stub\n"));
    … …  
    76104//   mmioInstallIOProc16        = _mmioInstallIOProc16@??     @120
    77105
    78 LPMMIOPROC WIN32API mmioInstallIOProcA(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
     106ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcA,
     107              FOURCC, fccIOProc,
     108              LPMMIOPROC, pIOProc,
     109              DWORD, dwFlags)
    79110{
    80111  dprintf(("WINMM:mmioInstallIOProcA - stub\n"));
    … …  
    82113}
    83114
    84 LPMMIOPROC WIN32API mmioInstallIOProcW(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
     115ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcW,
     116              FOURCC, fccIOProc,
     117              LPMMIOPROC, pIOProc,
     118              DWORD, dwFlags)
    85119{
    86120  dprintf(("WINMM:mmioInstallIOProcW - stub\n"));
    … …  
    92126//TODO: Not implemented
    93127/******************************************************************************/
    94 HMMIO WIN32API mmioOpenA(LPTSTR lpszFilename, LPMMIOINFO lpmmioinfo, DWORD fdwOpen)
     128ODINFUNCTION3(HMMIO, mmioOpenA,
     129              LPTSTR, lpszFilename,
     130              LPMMIOINFO, lpmmioinfo,
     131              DWORD, fdwOpen)
    95132{
    96133  dprintf(("WINMM:mmioOpenA %s - stub\n", lpszFilename));
    … …  
    98135}
    99136
    100 HMMIO WIN32API mmioOpenW(LPWSTR lpszFilename, LPMMIOINFO lpmmioinfo, DWORD fdwOpen)
     137ODINFUNCTION3(HMMIO, mmioOpenW,
     138              LPWSTR, lpszFilename,
     139              LPMMIOINFO, lpmmioinfo,
     140              DWORD, fdwOpen)
    101141{
    102142  dprintf(("WINMM:mmioOpenW - stub\n"));
    … …  
    104144}
    105145
    106 LONG WIN32API mmioRead(HMMIO hmmio, HPSTR pch, LONG cbRead)
     146ODINFUNCTION3(LONG, mmioRead,
     147              HMMIO, hmmio,
     148              HPSTR, pch,
     149              LONG, cbRead)
    107150{
    108151  dprintf(("WINMM:mmioRead - stub\n"));
    … …  
    110153}
    111154
    112 MMRESULT WIN32API mmioRenameA(LPCSTR pszFileName, LPCSTR pszNewFileName, LPMMIOINFO pmmioinfo, DWORD fdwRename)
     155ODINFUNCTION4(MMRESULT, mmioRenameA,
     156              LPCSTR, pszFileName,
     157              LPCSTR, pszNewFileName,
     158              LPMMIOINFO, pmmioinfo,
     159              DWORD, fdwRename)
    113160{
    114161  dprintf(("WINMM:mmioRenameA - stub\n"));
    … …  
    116163}
    117164
    118 MMRESULT WIN32API mmioRenameW(LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPMMIOINFO pmmioinfo, DWORD fdwRename)
     165ODINFUNCTION4(MMRESULT, mmioRenameW,
     166              LPCWSTR, pszFileName,
     167              LPCWSTR, pszNewFileName,
     168              LPMMIOINFO, pmmioinfo,
     169              DWORD, fdwRename)
    119170{
    120171  dprintf(("WINMM:mmioRenameW - stub\n"));
    … …  
    122173}
    123174
    124 LONG WIN32API mmioSeek(HMMIO hmmio, LONG lOffset, int nOrigin)
     175ODINFUNCTION3(LONG, mmioSeek,
     176              HMMIO, hmmio,
     177              LONG, lOffset,
     178              int, nOrigin)
    125179{
    126180  dprintf(("WINMM:mmioSeek - stub\n"));
    … …  
    128182}
    129183
    130 LRESULT WIN32API mmioSendMessage(HMMIO hmmio, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
     184ODINFUNCTION4(LRESULT, mmioSendMessage,
     185              HMMIO, hmmio,
     186              UINT, uMsg,
     187              LPARAM, lParam1,
     188              LPARAM, lParam2)
    131189{
    132190  dprintf(("WINMM:mmioSendMessage - stub\n"));
    … …  
    140198}
    141199
    142 MMRESULT WIN32API mmioSetInfo(HMMIO hmmio, const MMIOINFO *lpmmioinfo, UINT uReserved)
     200ODINFUNCTION3(MMRESULT, mmioSetInfo,
     201              HMMIO, hmmio,
     202              const MMIOINFO *, lpmmioinfo,
     203              UINT, uReserved)
    143204{
    144205  dprintf(("WINMM:mmioSetInfo - stub\n"));
    … …  
    148209
    149210/*****************************************************************************
    150  * Name      : FOURCC WIN32API OS2mmioStringToFOURCCA
    151  * Purpose   : Converts a null-terminated string to a four-character code
     211ODINFUNCTION2(*, :,
     212              FOURCC, WIN32API,
     213              OS2mmioStringToFOURCCA *, Purpose: Converts a null-terminated string to a four-character code
    152214 * Parameters: LPTSTR sz
    153215 *             UINT    wFlags
    154216 * Variables :
    155217 * Result    :
    156  * Remark    : 
     218 * Remark    :
    157219 * Status    :
    158220 *
    … …  
    160222 *****************************************************************************/
    161223
    162 FOURCC WIN32API mmioStringToFOURCCA(LPCSTR sz,
    163                                     UINT   wFlags)
     224ODINFUNCTION2(FOURCC, mmioStringToFOURCCA,
     225              LPCSTR, sz,
     226              UINT, wFlags)
    164227{
    165228  union
    166229  {
    167     ULONG ulFourcc; 
     230    ULONG ulFourcc;
    168231    UCHAR ucFourcc[5];
    169232  } unFourcc;
    170233
    171   unFourcc.ucFourcc[0] = sz[0]; 
    172   unFourcc.ucFourcc[1] = sz[1]; 
    173   unFourcc.ucFourcc[2] = sz[2]; 
    174   unFourcc.ucFourcc[3] = sz[3]; 
     234  unFourcc.ucFourcc[0] = sz[0];
     235  unFourcc.ucFourcc[1] = sz[1];
     236  unFourcc.ucFourcc[2] = sz[2];
     237  unFourcc.ucFourcc[3] = sz[3];
    175238  unFourcc.ucFourcc[4] = 0;     /* string termination */
    176239
    … …  
    187250
    188251/*****************************************************************************
    189  * Name      : FOURCC WIN32API mmioStringToFOURCCW
    190  * Purpose   : Converts a null-terminated string to a four-character code
     252ODINFUNCTION2(*, :,
     253              FOURCC, WIN32API,
     254              mmioStringToFOURCCW *, Purpose: Converts a null-terminated string to a four-character code
    191255 * Parameters: LPWSTR sz
    192256 *             UINT    wFlags
    193257 * Variables :
    194258 * Result    :
    195  * Remark    : 
     259 * Remark    :
    196260 * Status    :
    197261 *
    … …  
    199263 *****************************************************************************/
    200264
    201 FOURCC WIN32API mmioStringToFOURCCW(LPCWSTR sz,
    202                                     UINT   wFlags)
     265ODINFUNCTION2(FOURCC, mmioStringToFOURCCW,
     266              LPCWSTR, sz,
     267              UINT, wFlags)
    203268{
    204269  union
    205270  {
    206     ULONG ulFourcc; 
     271    ULONG ulFourcc;
    207272    UCHAR ucFourcc[5];
    208273  } unFourcc;
    … …  
    210275  LPSTR pszAscii;                                   /* pointer to ASCII string */
    211276  UCHAR ucBuffer[5];                                    /* buffer for FOURCC */
    212  
     277
    213278  pszAscii = UnicodeToAsciiString((LPWSTR)sz);
    214  
     279
    215280  strncpy ( (LPSTR) ucBuffer,
    216281           pszAscii,
    217282           sizeof (ucBuffer) );
    218  
     283
    219284  FreeAsciiString(pszAscii);
    220  
    221 
    222   unFourcc.ucFourcc[0] = ucBuffer[0]; 
    223   unFourcc.ucFourcc[1] = ucBuffer[1]; 
    224   unFourcc.ucFourcc[2] = ucBuffer[2]; 
    225   unFourcc.ucFourcc[3] = ucBuffer[3]; 
     285
     286
     287  unFourcc.ucFourcc[0] = ucBuffer[0];
     288  unFourcc.ucFourcc[1] = ucBuffer[1];
     289  unFourcc.ucFourcc[2] = ucBuffer[2];
     290  unFourcc.ucFourcc[3] = ucBuffer[3];
    226291  unFourcc.ucFourcc[4] = 0;                            /* string termination */
    227292
    … …  
    232297           sz,
    233298           wFlags));
    234  
     299
    235300  return unFourcc.ulFourcc; /* return FOURCC */
    236301}
    … …  
    240305//TODO: Not implemented
    241306/******************************************************************************/
    242 LONG WIN32API mmioWrite(HMMIO hmmio, const char *ch, LONG cbWrite)
     307ODINFUNCTION3(LONG, mmioWrite,
     308              HMMIO, hmmio,
     309              const char *, ch,
     310              LONG, cbWrite)
    243311{
    244312  dprintf(("WINMM:mmioWrite - stub\n"));
    245313  return 0;
    246314}
     315

  • trunk/src/winmm/os2timer.cpp

    r120 r588  
    1 /* $Id: os2timer.cpp,v 1.4 1999-06-19 10:54:48 sandervl Exp $ */
     1/* $Id: os2timer.cpp,v 1.5 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    99 *
    1010 */
     11
     12
     13/****************************************************************************
     14 * Includes                                                                 *
     15 ****************************************************************************/
     16
    1117#define INCL_DOSPROCESS
    1218#define INCL_DOSDATETIME
    1319#define INCL_DOSSEMAPHORES
    14 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     20#include <os2wrap.h>      //Odin32 OS/2 api wrappers
    1521#include <process.h>
    1622#include "win32type.h"
    … …  
    1925#include "misc.h"
    2026
     27
    2128static void _Optlink TimerHlpHandler(void *);
     29
    2230
    2331/******************************************************************************/
    … …  
    154162OS2Timer *OS2Timer::timers      = NULL;
    155163int       OS2Timer::timerPeriod = 0;
     164

  • trunk/src/winmm/playsound.cpp

    r120 r588  
    1 /* $Id: playsound.cpp,v 1.3 1999-06-19 10:54:48 sandervl Exp $ */
     1/* $Id: playsound.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
    12 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
     18#include <os2wrap.h>       //Odin32 OS/2 api wrappers
     19#include <odinwrap.h>
    1320#include "win32type.h"
    1421#include "misc.h"
    1522
     23ODINDEBUGCHANNEL(WINMM-PLAYSOUND)
     24
     25
    1626/*****************************************************************************
    17  * Name      : BOOL WIN32API PlaySound
    18  * Purpose   : Plays a sound specified by the given filename, resource, or
     27 *             Plays a sound specified by the given filename, resource, or
    1928 *             system event.
    2029 * Parameters: LPCSTR  pszSound
    … …  
    2837 * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
    2938 *****************************************************************************/
    30 BOOL WIN32API PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound )
     39
     40ODINFUNCTION3(BOOL, PlaySoundA,
     41              LPCSTR, pszSound,
     42              HMODULE, hmod,
     43              DWORD, fdwSound)
    3144{
    3245  dprintf(("WINMM:PlaySoundA not implemented\n"));
    3346  return(FALSE);
    3447}
     48
     49
    3550/*****************************************************************************
    36  * Name      : BOOL WIN32API PlaySoundW
    37  * Purpose   : Plays a sound specified by the given filename, resource, or
     51 *             Plays a sound specified by the given filename, resource, or
    3852 *             system event.
    3953 * Parameters: LPCSTR  pszSound
    … …  
    4761 * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
    4862 *****************************************************************************/
    49 BOOL WIN32API PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound )
     63
     64ODINFUNCTION3(BOOL, PlaySoundW,
     65              LPCWSTR, pszSound,
     66              HMODULE, hmod,
     67              DWORD, fdwSound)
    5068{
    5169  dprintf(("WINMM:PlaySoundW not implemented\n"));
    5270  return(FALSE);
    5371}
    54 /******************************************************************************/
    55 /******************************************************************************/
    56 BOOL WIN32API sndPlaySoundA(LPCSTR pszSound, UINT fuSound)
     72
     73
     74/*****************************************************************************
     75 *             Plays a sound specified by the given filename
     76 * Parameters: LPCSTR  pszSound
     77 *             UINT    fuSound
     78 * Variables :
     79 * Result    :
     80 * Remark    :
     81 * Status    :
     82 *
     83 * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
     84 *****************************************************************************/
     85
     86ODINFUNCTION2(BOOL, sndPlaySoundA,
     87              LPCSTR, pszSound,
     88              UINT, fuSound)
    5789{
    5890  dprintf(("WINMM:sndPlaySoundA not implemented\n"));
    5991  return(FALSE);
    6092}
    61 /******************************************************************************/
    62 /******************************************************************************/
    63 BOOL WIN32API sndPlaySoundW(LPCWSTR pszSound, UINT fuSound)
     93
     94
     95/*****************************************************************************
     96 *             Plays a sound specified by the given filename
     97 * Parameters: LPCWSTR  pszSound
     98 *             HMODULE  hMod
     99 *             DWORD    fdwSound
     100 * Variables :
     101 * Result    :
     102 * Remark    :
     103 * Status    :
     104 *
     105 * Author    : Patrick Haller [Tue, 1998/05/05 10:44]
     106 *****************************************************************************/
     107
     108ODINFUNCTION2(BOOL, sndPlaySoundW,
     109              LPCWSTR, pszSound,
     110              UINT, fuSound)
    64111{
    65112  dprintf(("WINMM:sndPlaySoundW not implemented\n"));
    66113  return(FALSE);
    67114}
    68 /******************************************************************************/
    69 /******************************************************************************/
     115

  • trunk/src/winmm/timegettime.cpp

    r95 r588  
    1 /* $Id: timegettime.cpp,v 1.2 1999-06-10 16:24:34 phaller Exp $ */
     1/* $Id: timegettime.cpp,v 1.3 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    66 *
    77 */
     8
     9/****************************************************************************
     10 * Includes                                                                 *
     11 ****************************************************************************/
     12
    813#include <os2win.h>
     14#include <odinwrap.h>
     15
     16
     17ODINDEBUGCHANNEL(WINMM-TIMEGETTIME)
    918
    1019/******************************************************************************/
    1120/******************************************************************************/
    12 DWORD WIN32API timeGetTime(void)
     21ODINFUNCTION0(DWORD, timeGetTime)
    1322{
    14 #ifdef DEBUG
    15 ////    WriteLog("WINMM:timeGetTime\n");
    16 #endif
    17     return O32_timeGetTime();
     23  return O32_timeGetTime();
    1824}
    1925/******************************************************************************/
    2026/******************************************************************************/
     27

  • trunk/src/winmm/wavein.cpp

    r95 r588  
    1 /* $Id: wavein.cpp,v 1.3 1999-06-10 16:24:35 phaller Exp $ */
     1/* $Id: wavein.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
    14 
     20#include <odinwrap.h>
    1521#include <stdio.h>
    1622#include <string.h>
    17 
    1823#include <misc.h>
    1924#include <unicode.h>
    … …  
    2227
    2328
     29ODINDEBUGCHANNEL(WINMM-WAVEIN)
     30
    2431// All stubs for now
    25 MMRESULT WIN32API waveInAddBuffer(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
     32ODINFUNCTION3(MMRESULT, waveInAddBuffer,
     33              HWAVEIN, hwi,
     34              LPWAVEHDR, pwh,
     35              UINT, cbwh)
    2636{
    2737  dprintf(("WINMM:waveInAddBuffer - stub\n"));
    … …  
    2939}
    3040
    31 MMRESULT WIN32API waveInClose(HWAVEIN hwi)
     41ODINFUNCTION1(MMRESULT, waveInClose,
     42              HWAVEIN, hwi)
    3243{
    3344  dprintf(("WINMM:waveInClose - stub\n"));
    … …  
    3546}
    3647
    37 MMRESULT WIN32API waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA pwic, UINT cbwic)
     48ODINFUNCTION3(MMRESULT, waveInGetDevCapsA,
     49              UINT, uDeviceID,
     50              LPWAVEINCAPSA, pwic,
     51              UINT, cbwic)
    3852{
    3953  dprintf(("WINMM:waveInGetDevCapsA(%d) - stub\n", uDeviceID ));
    … …  
    4155}
    4256
    43 MMRESULT WIN32API waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic)
     57ODINFUNCTION3(MMRESULT, waveInGetDevCapsW,
     58              UINT, uDeviceID,
     59              LPWAVEINCAPSW, pwic,
     60              UINT, cbwic)
    4461{
    4562  dprintf(("WINMM:waveInGetDevCapsW(%d) - stub\n", uDeviceID ));
    … …  
    4764}
    4865
    49 MMRESULT WIN32API waveInGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
     66ODINFUNCTION3(MMRESULT, waveInGetErrorTextA,
     67              MMRESULT, wError,
     68              LPSTR, lpText,
     69              UINT, cchText)
    5070{
    5171  dprintf(("WINMM:waveInGetErrorTextA(%d)\n", wError ));
    … …  
    6282}
    6383
    64 MMRESULT WIN32API waveInGetErrorTextW(MMRESULT wError, LPWSTR lpText, UINT cchText)
     84ODINFUNCTION3(MMRESULT, waveInGetErrorTextW,
     85              MMRESULT, wError,
     86              LPWSTR, lpText,
     87              UINT, cchText)
    6588{
    6689  dprintf(("WINMM:waveInGetErrorTextW(%d) - stub\n", wError ));
    … …  
    77100}
    78101
    79 MMRESULT WIN32API waveInGetID(HWAVEIN hwi, LPUINT puDeviceID)
     102ODINFUNCTION2(MMRESULT, waveInGetID,
     103              HWAVEIN, hwi,
     104              LPUINT, puDeviceID)
    80105{
    81106  dprintf(("WINMM:waveInGetID - stub\n"));
    … …  
    83108}
    84109
    85 UINT WIN32API waveInGetNumDevs(void)
     110ODINFUNCTION0(UINT, waveInGetNumDevs)
    86111{
    87112  dprintf(("WINMM:waveInGetNumDevs - stub\n"));
    … …  
    89114}
    90115
    91 MMRESULT WIN32API waveInGetPosition(HWAVEIN hwi, LPMMTIME pmmt, UINT cbmmt)
     116ODINFUNCTION3(MMRESULT, waveInGetPosition,
     117              HWAVEIN, hwi,
     118              LPMMTIME, pmmt,
     119              UINT, cbmmt)
    92120{
    93121  dprintf(("WINMM:waveInGetPosition - stub\n"));
    … …  
    95123}
    96124
    97 MMRESULT WIN32API waveInMessage(HWAVEIN hwi, UINT uMsg, DWORD dw1, DWORD dw2)
     125ODINFUNCTION4(MMRESULT, waveInMessage,
     126              HWAVEIN, hwi,
     127              UINT, uMsg,
     128              DWORD, dw1,
     129              DWORD, dw2)
    98130{
    99131  dprintf(("WINMM:waveInMessage - stub\n"));
    … …  
    102134
    103135
    104 MMRESULT WIN32API waveInOpen(LPHWAVEIN phwi, UINT uDeviceID,
    105                              const LPWAVEFORMATEX pwfx,
    106                              DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen)
     136ODINFUNCTION6(MMRESULT, waveInOpen,
     137              LPHWAVEIN, phwi,
     138              UINT, uDeviceID,
     139              const LPWAVEFORMATEX, pwfx,
     140              DWORD, dwCallback,
     141              DWORD, dwInstance,
     142              DWORD, fdwOpen)
    107143{
    108144  dprintf(("WINMM:waveInOpen - stub\n"));
    … …  
    110146}
    111147
    112 MMRESULT WIN32API waveInPrepareHeader(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
     148ODINFUNCTION3(MMRESULT, waveInPrepareHeader,
     149              HWAVEIN, hwi,
     150              LPWAVEHDR, pwh,
     151              UINT, cbwh)
    113152{
    114153  dprintf(("WINMM:waveInPrepareHeader - stub\n"));
    … …  
    116155}
    117156
    118 MMRESULT WIN32API waveInReset(HWAVEIN hwi)
     157ODINFUNCTION1(MMRESULT, waveInReset,
     158              HWAVEIN, hwi)
    119159{
    120160  dprintf(("WINMM:waveInReset - stub\n"));
    … …  
    122162}
    123163
    124 MMRESULT WIN32API waveInStart(HWAVEIN hwi)
     164ODINFUNCTION1(MMRESULT, waveInStart,
     165              HWAVEIN, hwi)
    125166{
    126167  dprintf(("WINMM:waveInStart - stub\n"));
    … …  
    128169}
    129170
    130 MMRESULT WIN32API waveInStop(HWAVEIN hwi)
     171ODINFUNCTION1(MMRESULT, waveInStop,
     172              HWAVEIN, hwi)
    131173{
    132174  dprintf(("WINMM:waveInStop - stub\n"));
    … …  
    134176}
    135177
    136 MMRESULT WIN32API waveInUnprepareHeader(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh)
     178ODINFUNCTION3(MMRESULT, waveInUnprepareHeader,
     179              HWAVEIN, hwi,
     180              LPWAVEHDR, pwh,
     181              UINT, cbwh)
    137182{
    138183  dprintf(("WINMM:waveInUnprepareHeader - stub\n"));
    … …  
    140185}
    141186
     187

  • trunk/src/winmm/waveout.cpp

    r95 r588  
    1 /* $Id: waveout.cpp,v 1.3 1999-06-10 16:24:35 phaller Exp $ */
     1/* $Id: waveout.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
    1319#include <mmsystem.h>
     20#include <odinwrap.h>
    1421
    1522#include <string.h>
    … …  
    2229#include "winmm.h"
    2330
    24 /******************************************************************************/
    25 /******************************************************************************/
    26 MMRESULT WIN32API waveOutOpen(LPHWAVEOUT phwo, UINT uDeviceID,
    27                               const LPWAVEFORMATEX pwfx, DWORD dwCallback,
    28                               DWORD dwInstance, DWORD fdwOpen)
    29 {
    30  MMRESULT rc;
    31 
    32   dprintf(("WINMM:waveOutOpen %d %X %X\n", uDeviceID, fdwOpen, dwCallback));
    33   dprintf(("WINMM:waveOutOpen = %X\n", waveOutOpen));
     31ODINDEBUGCHANNEL(WINMM-WAVEOUT)
     32
     33
     34/******************************************************************************/
     35/******************************************************************************/
     36ODINFUNCTION6(MMRESULT, waveOutOpen,
     37              LPHWAVEOUT, phwo,
     38              UINT, uDeviceID,
     39              const LPWAVEFORMATEX, pwfx,
     40              DWORD, dwCallback,
     41              DWORD, dwInstance,
     42              DWORD, fdwOpen)
     43{
     44  MMRESULT rc;
    3445
    3546  if(pwfx == NULL)
    … …  
    6576        return(rc);
    6677  }
    67   dprintf(("WINMM:waveOutOpen success\n"));
    6878  return(MMSYSERR_NOERROR);
    6979}
    7080/******************************************************************************/
    7181/******************************************************************************/
    72 MMRESULT WIN32API waveOutWrite(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    73 {
    74  DartWaveOut *dwave = (DartWaveOut *)hwo;
    75 
    76 #ifdef DEBUG1
    77   WriteLog("WINMM:waveOutWrite %X %d\n", pwh, cbwh);
    78 #endif
    79   if(DartWaveOut::find(dwave) == TRUE) {
    80         if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
    81                 return WAVERR_UNPREPARED;
    82         if(pwh->dwFlags & WHDR_INQUEUE)
    83                 return WAVERR_STILLPLAYING;
    84 
    85         pwh->dwFlags |= WHDR_INQUEUE;
    86         pwh->dwFlags &= ~WHDR_DONE;
    87 
    88         return(dwave->write(pwh, cbwh));
    89   }
    90   else  return(MMSYSERR_INVALHANDLE);
    91 }
    92 /******************************************************************************/
    93 /******************************************************************************/
    94 MMRESULT WIN32API waveOutReset(HWAVEOUT hwaveout)
    95 {
    96  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
    97 
    98   dprintf(("WINMM:waveOutReset %X\n", hwaveout));
    99   if(DartWaveOut::find(dwave) == TRUE) {
    100         return(dwave->reset());
    101   }
    102   else  return(MMSYSERR_INVALHANDLE);
    103 }
    104 /******************************************************************************/
    105 /******************************************************************************/
    106 MMRESULT WIN32API waveOutBreakLoop(HWAVEOUT hwaveout)
    107 {
    108  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
     82ODINFUNCTION3(MMRESULT, waveOutWrite,
     83              HWAVEOUT, hwo,
     84              LPWAVEHDR, pwh,
     85              UINT, cbwh)
     86{
     87  DartWaveOut *dwave = (DartWaveOut *)hwo;
     88
     89  if(DartWaveOut::find(dwave) == TRUE)
     90  {
     91    if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
     92      return WAVERR_UNPREPARED;
     93
     94    if(pwh->dwFlags & WHDR_INQUEUE)
     95      return WAVERR_STILLPLAYING;
     96
     97    pwh->dwFlags |= WHDR_INQUEUE;
     98    pwh->dwFlags &= ~WHDR_DONE;
     99
     100    return(dwave->write(pwh, cbwh));
     101  }
     102  else
     103    return(MMSYSERR_INVALHANDLE);
     104}
     105/******************************************************************************/
     106/******************************************************************************/
     107ODINFUNCTION1(MMRESULT, waveOutReset,
     108              HWAVEOUT, hwaveout)
     109{
     110  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
     111
     112  if(DartWaveOut::find(dwave) == TRUE)
     113    return(dwave->reset());
     114  else
     115    return(MMSYSERR_INVALHANDLE);
     116}
     117/******************************************************************************/
     118/******************************************************************************/
     119ODINFUNCTION1(MMRESULT, waveOutBreakLoop,
     120              HWAVEOUT, hwaveout)
     121{
     122  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
    109123
    110124  dprintf(("WINMM:waveOutBreakLoop (implemented as reset) %X\n", hwaveout));
    111   if(DartWaveOut::find(dwave) == TRUE) {
    112         return(dwave->reset());
    113   }
    114   else  return(MMSYSERR_INVALHANDLE);
    115 }
    116 /******************************************************************************/
    117 /******************************************************************************/
    118 MMRESULT WIN32API waveOutClose(HWAVEOUT hwaveout)
    119 {
    120  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
    121 
    122   dprintf(("WINMM:waveOutClose %X\n", hwaveout));
    123   if(DartWaveOut::find(dwave) == TRUE) {
    124         if(dwave->getState() == STATE_PLAYING)
    125                 return(WAVERR_STILLPLAYING);
    126         delete dwave;
    127         return(MMSYSERR_NOERROR);
    128   }
    129   else  return(MMSYSERR_INVALHANDLE);
    130 }
    131 /******************************************************************************/
    132 /******************************************************************************/
    133 MMRESULT WIN32API waveOutPause(HWAVEOUT hwaveout)
    134 {
    135  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
    136 
    137   dprintf(("WINMM:waveOutPause %X\n", hwaveout));
    138   if(DartWaveOut::find(dwave) == TRUE) {
    139         return(dwave->pause());
    140   }
    141   else  return(MMSYSERR_INVALHANDLE);
    142 }
    143 /******************************************************************************/
    144 /******************************************************************************/
    145 MMRESULT WIN32API waveOutRestart(HWAVEOUT hwaveout)
    146 {
    147  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
    148 
    149   dprintf(("WINMM:waveOutRestart %X\n", hwaveout));
    150   if(DartWaveOut::find(dwave) == TRUE) {
    151         return(dwave->restart());
    152   }
    153   else  return(MMSYSERR_INVALHANDLE);
    154 }
    155 /******************************************************************************/
    156 /******************************************************************************/
    157 MMRESULT WIN32API waveOutPrepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    158 {
    159  DartWaveOut *dwave = (DartWaveOut *)hwo;
    160 
    161   dprintf(("WINMM:waveOutPrepareHeader %X %d\n", pwh, cbwh));
    162 
    163   if(DartWaveOut::find(dwave) == TRUE) {
    164         if(pwh->dwFlags & WHDR_INQUEUE)
    165                 return WAVERR_STILLPLAYING;
    166         pwh->dwFlags |= WHDR_PREPARED;
    167         pwh->dwFlags &= ~WHDR_DONE;
    168         pwh->lpNext   = NULL;
    169         return(MMSYSERR_NOERROR);
    170   }
    171   else  return(MMSYSERR_INVALHANDLE);
    172 }
    173 /******************************************************************************/
    174 /******************************************************************************/
    175 MMRESULT WIN32API waveOutUnprepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh)
    176 {
    177  DartWaveOut *dwave = (DartWaveOut *)hwo;
    178 
    179   dprintf(("WINMM:waveOutUnprepareHeader %X %d\n", pwh, cbwh));
    180   if(DartWaveOut::find(dwave) == TRUE) {
    181         if(pwh->dwFlags & WHDR_INQUEUE)
    182                 return WAVERR_STILLPLAYING;
    183 
    184         pwh->dwFlags &= ~WHDR_PREPARED;
    185         pwh->dwFlags |= WHDR_DONE;
    186         return(MMSYSERR_NOERROR);
    187   }
    188   else  return(MMSYSERR_INVALHANDLE);
    189 }
    190 /******************************************************************************/
    191 /******************************************************************************/
    192 MMRESULT WIN32API waveOutGetPosition(HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt)
     125  if(DartWaveOut::find(dwave) == TRUE)
     126    return(dwave->reset());
     127  else
     128    return(MMSYSERR_INVALHANDLE);
     129}
     130/******************************************************************************/
     131/******************************************************************************/
     132ODINFUNCTION1(MMRESULT, waveOutClose,
     133              HWAVEOUT, hwaveout)
     134{
     135  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
     136
     137  if(DartWaveOut::find(dwave) == TRUE)
     138  {
     139    if(dwave->getState() == STATE_PLAYING)
     140      return(WAVERR_STILLPLAYING);
     141
     142    delete dwave;
     143    return(MMSYSERR_NOERROR);
     144  }
     145  else
     146    return(MMSYSERR_INVALHANDLE);
     147}
     148/******************************************************************************/
     149/******************************************************************************/
     150ODINFUNCTION1(MMRESULT, waveOutPause,
     151              HWAVEOUT, hwaveout)
     152{
     153  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
     154
     155  if(DartWaveOut::find(dwave) == TRUE)
     156    return(dwave->pause());
     157  else
     158    return(MMSYSERR_INVALHANDLE);
     159}
     160/******************************************************************************/
     161/******************************************************************************/
     162ODINFUNCTION1(MMRESULT, waveOutRestart,
     163              HWAVEOUT, hwaveout)
     164{
     165  DartWaveOut *dwave = (DartWaveOut *)hwaveout;
     166
     167  if(DartWaveOut::find(dwave) == TRUE)
     168    return(dwave->restart());
     169  else
     170    return(MMSYSERR_INVALHANDLE);
     171}
     172/******************************************************************************/
     173/******************************************************************************/
     174ODINFUNCTION3(MMRESULT, waveOutPrepareHeader,
     175              HWAVEOUT, hwo,
     176              LPWAVEHDR, pwh,
     177              UINT, cbwh)
     178{
     179  DartWaveOut *dwave = (DartWaveOut *)hwo;
     180
     181  if(DartWaveOut::find(dwave) == TRUE)
     182  {
     183    if(pwh->dwFlags & WHDR_INQUEUE)
     184      return WAVERR_STILLPLAYING;
     185
     186    pwh->dwFlags |= WHDR_PREPARED;
     187    pwh->dwFlags &= ~WHDR_DONE;
     188    pwh->lpNext   = NULL;
     189    return(MMSYSERR_NOERROR);
     190  }
     191  else
     192    return(MMSYSERR_INVALHANDLE);
     193}
     194/******************************************************************************/
     195/******************************************************************************/
     196ODINFUNCTION3(MMRESULT, waveOutUnprepareHeader,
     197              HWAVEOUT, hwo,
     198              LPWAVEHDR, pwh,
     199              UINT, cbwh)
     200{
     201  DartWaveOut *dwave = (DartWaveOut *)hwo;
     202
     203  if(DartWaveOut::find(dwave) == TRUE)
     204  {
     205    if(pwh->dwFlags & WHDR_INQUEUE)
     206      return WAVERR_STILLPLAYING;
     207
     208    pwh->dwFlags &= ~WHDR_PREPARED;
     209    pwh->dwFlags |= WHDR_DONE;
     210   return(MMSYSERR_NOERROR);
     211  }
     212  else
     213   return(MMSYSERR_INVALHANDLE);
     214}
     215/******************************************************************************/
     216/******************************************************************************/
     217ODINFUNCTION3(MMRESULT, waveOutGetPosition,
     218              HWAVEOUT, hwo,
     219              LPMMTIME, pmmt,
     220              UINT, cbmmt)
    193221{
    194222  DartWaveOut *dwave = (DartWaveOut *)hwo;
    195223  dprintf(("WINMM:waveOutGetPosition - not implemented\n"));
    196   if(DartWaveOut::find(dwave) == TRUE) {
    197         return(MMSYSERR_NOERROR);
    198   }
    199   else  return(MMSYSERR_INVALHANDLE);
    200 }
    201 /******************************************************************************/
    202 /******************************************************************************/
    203 MMRESULT WIN32API waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA pwoc, UINT cbwoc)
    204 {
    205   dprintf(("WINMM:waveOutGetDevCapsA - stub\n"));
     224  if(DartWaveOut::find(dwave) == TRUE)
     225    return(MMSYSERR_NOERROR);
     226  else
     227    return(MMSYSERR_INVALHANDLE);
     228}
     229/******************************************************************************/
     230/******************************************************************************/
     231ODINFUNCTION3(MMRESULT, waveOutGetDevCapsA,
     232              UINT, uDeviceID,
     233              LPWAVEOUTCAPSA, pwoc,
     234              UINT, cbwoc)
     235{
     236  dprintf(("WINMM:waveOutGetDevCapsA - not implemented\n"));
    206237  // we have to fill in this thing
    207238  pwoc->wMid = 0;                  /* manufacturer ID */
    … …  
    224255/******************************************************************************/
    225256/******************************************************************************/
    226 MMRESULT WIN32API waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc)
    227 {
    228   dprintf(("WINMM:waveOutGetDevCapsW - stub\n"));
     257ODINFUNCTION3(MMRESULT, waveOutGetDevCapsW,
     258              UINT, uDeviceID,
     259              LPWAVEOUTCAPSW, pwoc,
     260              UINT, cbwoc)
     261{
     262  dprintf(("WINMM:waveOutGetDevCapsW - not implemented\n"));
    229263  // we have to fill in this thing
    230264  pwoc->wMid = 0;                  /* manufacturer ID */
    … …  
    247281/******************************************************************************/
    248282/******************************************************************************/
    249 UINT WIN32API waveOutGetNumDevs(void)
    250 {
    251   dprintf(("WINMM:waveOutGetNumDevs\n"));
     283ODINFUNCTION0(UINT, waveOutGetNumDevs)
     284{
    252285  return 1;
    253286}
    254287/******************************************************************************/
    255288/******************************************************************************/
    256 MMRESULT WIN32API waveOutGetErrorTextA(MMRESULT wError, LPSTR lpText, UINT cchText)
    257 {
    258   dprintf(("WINMM:waveOutGetErrorTextA(%d)\n", wError ));
     289ODINFUNCTION3(MMRESULT, waveOutGetErrorTextA,
     290              MMRESULT, wError,
     291              LPSTR, lpText,
     292              UINT, cchText)
     293{
    259294  char * theMsg = getWinmmMsg( wError );
    260295  if ( theMsg )
    … …  
    269304}
    270305
    271 MMRESULT WIN32API waveOutGetErrorTextW(MMRESULT wError, LPWSTR lpText, UINT cchText)
    272 {
    273   dprintf(("WINMM:waveOutGetErrorTextW(%d) - stub\n", wError ));
     306ODINFUNCTION3(MMRESULT, waveOutGetErrorTextW,
     307              MMRESULT, wError,
     308              LPWSTR, lpText,
     309              UINT, cchText)
     310{
    274311  char * theMsg = getWinmmMsg( wError );
    275312  if ( theMsg )
    … …  
    284321}
    285322
    286 MMRESULT WIN32API waveOutGetID(HWAVEOUT hwo, LPUINT puDeviceID)
    287 {
    288   dprintf(("WINMM:waveOutGetID" ));
     323ODINFUNCTION2(MMRESULT, waveOutGetID,
     324              HWAVEOUT, hwo,
     325              LPUINT, puDeviceID)
     326{
    289327  DartWaveOut *dwave = (DartWaveOut *)hwo;
    290328  if(DartWaveOut::find(dwave) == TRUE)
    … …  
    297335}
    298336
    299 MMRESULT WIN32API waveOutGetPitch(HWAVEOUT hwo, LPDWORD pdwPitch)
    300 {
    301   dprintf(("WINMM:waveOutGetPitch"));
    302   DartWaveOut *dwave = (DartWaveOut *)hwo;
    303   if(DartWaveOut::find(dwave) == TRUE)
    304   {
    305     return MMSYSERR_NOTSUPPORTED;
    306   }
    307   else
    308     return(MMSYSERR_INVALHANDLE);
    309 }
    310 
    311 MMRESULT WIN32API waveOutSetPitch(HWAVEOUT hwo, DWORD dwPitch)
    312 {
    313   dprintf(("WINMM:waveOutSetPitch"));
    314   DartWaveOut *dwave = (DartWaveOut *)hwo;
    315   if(DartWaveOut::find(dwave) == TRUE)
    316   {
    317     return MMSYSERR_NOTSUPPORTED;
    318   }
    319   else
    320     return(MMSYSERR_INVALHANDLE);
    321 }
    322 
    323 MMRESULT WIN32API waveOutGetVolume(HWAVEOUT hwo, LPDWORD pdwVolume)
    324 {
    325   dprintf(("WINMM:waveOutGetVolume"));
    326   DartWaveOut *dwave = (DartWaveOut *)hwo;
    327   if(DartWaveOut::find(dwave) == TRUE)
    328   {
    329     return MMSYSERR_NOTSUPPORTED;
    330   }
    331   else
    332     return(MMSYSERR_INVALHANDLE);
    333 }
    334 
    335 MMRESULT WIN32API waveOutSetVolume(HWAVEOUT hwo, DWORD dwVolume)
    336 {
    337   dprintf(("WINMM:waveOutSetVolume"));
    338   DartWaveOut *dwave = (DartWaveOut *)hwo;
    339   if(DartWaveOut::find(dwave) == TRUE)
    340   {
    341     return MMSYSERR_NOTSUPPORTED;
    342   }
    343   else
    344     return(MMSYSERR_INVALHANDLE);
    345 }
    346 
    347 MMRESULT WIN32API waveOutGetPlaybackRate(HWAVEOUT hwo, LPDWORD pdwRate)
    348 {
    349   dprintf(("WINMM:waveOutGetPlaybackRate"));
    350   DartWaveOut *dwave = (DartWaveOut *)hwo;
    351   if(DartWaveOut::find(dwave) == TRUE)
    352   {
    353     return MMSYSERR_NOTSUPPORTED;
    354   }
    355   else
    356     return(MMSYSERR_INVALHANDLE);
    357 }
    358 
    359 MMRESULT WIN32API waveOutSetPlaybackRate(HWAVEOUT hwo, DWORD dwRate)
    360 {
    361   dprintf(("WINMM:waveOutSetPlaybackRate"));
    362   DartWaveOut *dwave = (DartWaveOut *)hwo;
    363   if(DartWaveOut::find(dwave) == TRUE)
    364   {
    365     return MMSYSERR_NOTSUPPORTED;
    366   }
    367   else
    368     return(MMSYSERR_INVALHANDLE);
    369 }
    370 
    371 MMRESULT WIN32API waveOutMessage(HWAVEOUT hwo, UINT uMsg, DWORD dw1, DWORD dw2)
    372 {
    373   dprintf(("WINMM:waveOutMessage"));
    374   DartWaveOut *dwave = (DartWaveOut *)hwo;
    375   if(DartWaveOut::find(dwave) == TRUE)
    376   {
    377     return MMSYSERR_NOTSUPPORTED;
    378   }
    379   else
    380     return(MMSYSERR_INVALHANDLE);
    381 }
    382 
     337ODINFUNCTION2(MMRESULT, waveOutGetPitch,
     338              HWAVEOUT, hwo,
     339              LPDWORD, pdwPitch)
     340{
     341  DartWaveOut *dwave = (DartWaveOut *)hwo;
     342  if(DartWaveOut::find(dwave) == TRUE)
     343    return MMSYSERR_NOTSUPPORTED;
     344  else
     345    return(MMSYSERR_INVALHANDLE);
     346}
     347
     348ODINFUNCTION2(MMRESULT, waveOutSetPitch,
     349              HWAVEOUT, hwo,
     350              DWORD, dwPitch)
     351{
     352  DartWaveOut *dwave = (DartWaveOut *)hwo;
     353  if(DartWaveOut::find(dwave) == TRUE)
     354    return MMSYSERR_NOTSUPPORTED;
     355  else
     356    return(MMSYSERR_INVALHANDLE);
     357}
     358
     359ODINFUNCTION2(MMRESULT, waveOutGetVolume,
     360              HWAVEOUT, hwo,
     361              LPDWORD, pdwVolume)
     362{
     363  DartWaveOut *dwave = (DartWaveOut *)hwo;
     364  if(DartWaveOut::find(dwave) == TRUE)
     365  {
     366    return MMSYSERR_NOTSUPPORTED;
     367  }
     368  else
     369    return(MMSYSERR_INVALHANDLE);
     370}
     371
     372ODINFUNCTION2(MMRESULT, waveOutSetVolume,
     373              HWAVEOUT, hwo,
     374              DWORD, dwVolume)
     375{
     376  DartWaveOut *dwave = (DartWaveOut *)hwo;
     377  if(DartWaveOut::find(dwave) == TRUE)
     378  {
     379    return MMSYSERR_NOTSUPPORTED;
     380  }
     381  else
     382    return(MMSYSERR_INVALHANDLE);
     383}
     384
     385ODINFUNCTION2(MMRESULT, waveOutGetPlaybackRate,
     386              HWAVEOUT, hwo,
     387              LPDWORD, pdwRate)
     388{
     389  DartWaveOut *dwave = (DartWaveOut *)hwo;
     390  if(DartWaveOut::find(dwave) == TRUE)
     391  {
     392    return MMSYSERR_NOTSUPPORTED;
     393  }
     394  else
     395    return(MMSYSERR_INVALHANDLE);
     396}
     397
     398ODINFUNCTION2(MMRESULT, waveOutSetPlaybackRate,
     399              HWAVEOUT, hwo,
     400              DWORD, dwRate)
     401{
     402  DartWaveOut *dwave = (DartWaveOut *)hwo;
     403  if(DartWaveOut::find(dwave) == TRUE)
     404  {
     405    return MMSYSERR_NOTSUPPORTED;
     406  }
     407  else
     408    return(MMSYSERR_INVALHANDLE);
     409}
     410
     411ODINFUNCTION4(MMRESULT, waveOutMessage,
     412              HWAVEOUT, hwo,
     413              UINT, uMsg,
     414              DWORD, dw1,
     415              DWORD, dw2)
     416{
     417  DartWaveOut *dwave = (DartWaveOut *)hwo;
     418  if(DartWaveOut::find(dwave) == TRUE)
     419  {
     420    return MMSYSERR_NOTSUPPORTED;
     421  }
     422  else
     423    return(MMSYSERR_INVALHANDLE);
     424}
     425
     426

  • trunk/src/winmm/winmm.cpp

    r95 r588  
    1 /* $Id: winmm.cpp,v 1.3 1999-06-10 16:24:35 phaller Exp $ */
     1/* $Id: winmm.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
     13
     14/****************************************************************************
     15 * Includes                                                                 *
     16 ****************************************************************************/
     17
    1218#include <os2win.h>
     19#include <odinwrap.h>
    1320#include "misc.h"
    1421
    1522#include "os2timer.h"
    1623
     24ODINDEBUGCHANNEL(WINMM-WINMM)
     25
     26
    1727/******************************************************************************/
    18 UINT WIN32API mmsystemGetVersion(void)
     28ODINFUNCTION0(UINT, mmsystemGetVersion)
    1929{
    20   dprintf(("WINMM:mmsystemGetVersion\n"));
    2130  return 4;
    2231}
    2332
    2433/******************************************************************************/
    25 MMRESULT WIN32API timeGetDevCaps(LPTIMECAPS ptc, UINT cbtc)
     34ODINFUNCTION2(MMRESULT, timeGetDevCaps,
     35              LPTIMECAPS, ptc,
     36              UINT, cbtc)
    2637{
    27     dprintf(("WINMM:timeGetDevCaps Not really Implemented\n"));
    28     ptc->wPeriodMin = 1;
    29     ptc->wPeriodMax = 20;
    30     return TIMERR_NOERROR;
     38  dprintf(("WINMM:timeGetDevCaps Not really Implemented\n"));
     39  ptc->wPeriodMin = 1;
     40  ptc->wPeriodMax = 20;
     41  return TIMERR_NOERROR;
    3142}
    3243
    3344/******************************************************************************/
    34 MMRESULT WIN32API timeBeginPeriod(UINT cMilliseconds)
     45ODINFUNCTION1(MMRESULT, timeBeginPeriod,
     46              UINT, cMilliseconds)
    3547{
    36     dprintf(("WINMM:timeBeginPeriod %d ms\n", cMilliseconds));
    37     return TIMERR_NOERROR;
     48  dprintf(("WINMM: timeBeginPeriod not implemented.\n"));
     49  return TIMERR_NOERROR;
    3850}
    3951/******************************************************************************/
    4052/******************************************************************************/
    41 MMRESULT WIN32API timeEndPeriod(UINT cMilliseconds)
     53ODINFUNCTION1(MMRESULT, timeEndPeriod,
     54              UINT, cMilliseconds)
    4255{
    43     dprintf(("WINMM:timeEndPeriod %d ms\n", cMilliseconds));
    44     return TIMERR_NOERROR;
     56  dprintf(("WINMM: timeEndPeriod not implemented.\n"));
     57  return TIMERR_NOERROR;
    4558}
    4659/******************************************************************************/
    4760/******************************************************************************/
    48 MMRESULT WIN32API timeKillEvent(UINT IDEvent)
     61ODINFUNCTION1(MMRESULT, timeKillEvent,
     62              UINT, IDEvent)
    4963{
    50     dprintf(("WINMM:timeKillEvent Not Implemented\n"));
    51     delete((OS2Timer *)IDEvent);
    52     return TIMERR_NOERROR;
     64  dprintf(("WINMM:timeKillEvent Not Implemented\n"));
     65  delete((OS2Timer *)IDEvent);
     66  return TIMERR_NOERROR;
    5367}
    5468/******************************************************************************/
    5569/******************************************************************************/
    56 MMRESULT WIN32API timeSetEvent(UINT wDelay, UINT wResolution, LPTIMECALLBACK lptc,
    57                                   DWORD dwUser, UINT fuEvent)
     70ODINFUNCTION5(MMRESULT, timeSetEvent,
     71              UINT, wDelay,
     72              UINT, wResolution,
     73              LPTIMECALLBACK, lptc,
     74              DWORD, dwUser,
     75              UINT, fuEvent)
    5876{
    59  OS2Timer *timer;
     77  OS2Timer *timer;
    6078
    61     dprintf(("WINMM:timeSetEvent %d\n", wDelay));
     79  timer = new OS2Timer();
     80  if(timer == NULL)
     81      return(0);
    6282
    63     timer = new OS2Timer();
    64     if(timer == NULL) {
    65         return(0);
    66     }
    67     if(timer->StartTimer(wDelay, wResolution, lptc, dwUser, fuEvent) == FALSE) {
    68         dprintf(("WINMM:timeSetEvent: couldn't start timer!\n"));
    69         delete(timer);
    70         return(0);
    71     }
    72     return(MMRESULT)timer;
     83  if(timer->StartTimer(wDelay, wResolution, lptc, dwUser, fuEvent) == FALSE)
     84  {
     85    dprintf(("WINMM:timeSetEvent: couldn't start timer!\n"));
     86    delete(timer);
     87    return(0);
     88  }
     89  return(MMRESULT)timer;
    7390}
    7491
    7592/******************************************************************************/
    76 MMRESULT WIN32API timeGetSystemTime( LPMMTIME arg1, UINT  arg2)
     93ODINFUNCTION2(MMRESULT, timeGetSystemTime,
     94              LPMMTIME, arg1,
     95              UINT, arg2)
    7796{
    78     dprintf(("WINMM:timeGetSystemTime\n"));
    79     return O32_timeGetSystemTime(arg1, arg2);
     97  return O32_timeGetSystemTime(arg1, arg2);
    8098}
     99
Note: See TracChangeset for help on using the changeset viewer.