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

Add: added ODINWRAP support for WINMM

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.