Changeset 5366 for trunk/src


Ignore:
Timestamp:
Mar 24, 2001, 4:40:04 PM (24 years ago)
Author:
sandervl
Message:

Enabled DirectAudio wave playback interface (if present)

Location:
trunk/src/winmm
Files:
4 edited

Legend:

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

    r5356 r5366  
    2626#define  INCL_DOSMODULEMGR
    2727#define  INCL_DOSPROCESS
    28 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     28#include <os2wrap.h>    //Odin32 OS/2 api wrappers
    2929#include <stdlib.h>
    3030#include <stdio.h>
     
    3939#include "auxiliary.h"
    4040
    41 #define DBG_LOCALLOG    DBG_initterm
     41#define DBG_LOCALLOG    DBG_initterm
    4242#include "dbglocal.h"
    4343
     
    5858BOOL WINAPI OdinLibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
    5959{
    60   static BOOL                   bInitDone = FALSE;
    61  
     60  static BOOL           bInitDone = FALSE;
     61
    6262  switch (fdwReason)
    6363    {
    6464    case DLL_PROCESS_ATTACH:
    65       if (!MULTIMEDIA_CreateIData(hinstDLL))
    66         return FALSE;
    67      
    68       if (!bInitDone) { /* to be done only once */
    69             if (!MULTIMEDIA_MciInit() /*|| !MMDRV_Init() */ ) {
    70           MULTIMEDIA_DeleteIData();
    71           return FALSE;
    72             }
    73         bInitDone = TRUE;       
    74       }
    75      
    76         return TRUE;
     65        if (!MULTIMEDIA_CreateIData(hinstDLL))
     66            return FALSE;
     67
     68        if (!bInitDone) { /* to be done only once */
     69            if (!MULTIMEDIA_MciInit() /*|| !MMDRV_Init() */ ) {
     70                MULTIMEDIA_DeleteIData();
     71                return FALSE;
     72            }
     73            bInitDone = TRUE;
     74        }
     75        return TRUE;
    7776
    7877   case DLL_THREAD_ATTACH:
    7978   case DLL_THREAD_DETACH:
    80         return TRUE;
     79        return TRUE;
    8180
    8281   case DLL_PROCESS_DETACH:
    8382        MULTIMEDIA_DeleteIData();
    8483        auxOS2Close(); /* SvL: Close aux device if necessary */
    85         IRTMidiShutdown;  /* JT: Shutdown RT Midi subsystem, if running. */
    86         ctordtorTerm();
    87         return TRUE;
     84        IRTMidiShutdown;  /* JT: Shutdown RT Midi subsystem, if running. */
     85        ctordtorTerm();
     86        return TRUE;
    8887   }
    8988   return FALSE;
     
    9998ULONG DLLENTRYPOINT_CCONV DLLENTRYPOINT_NAME(ULONG hModule, ULONG ulFlag)
    10099{
    101    size_t i;
    102    APIRET rc;
     100    /*-------------------------------------------------------------------------*/
     101    /* If ulFlag is zero then the DLL is being loaded so initialization should */
     102    /* be performed.  If ulFlag is 1 then the DLL is being freed so            */
     103    /* termination should be performed.                                        */
     104    /*-------------------------------------------------------------------------*/
    103105
    104    /*-------------------------------------------------------------------------*/
    105    /* If ulFlag is zero then the DLL is being loaded so initialization should */
    106    /* be performed.  If ulFlag is 1 then the DLL is being freed so            */
    107    /* termination should be performed.                                        */
    108    /*-------------------------------------------------------------------------*/
     106    switch (ulFlag)
     107    {
     108    case 0 :
     109        ctordtorInit();
    109110
    110    switch (ulFlag) {
    111       case 0 :
    112          ctordtorInit();
     111        ParseLogStatus();
    113112
    114          ParseLogStatus();
     113        CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
     114        dllHandle = RegisterLxDll(hModule, OdinLibMain, (PVOID)&_Resource_PEResTab);
     115        if(dllHandle == 0)
     116            return 0UL;/* Error */
    115117
    116          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
     118        dprintf(("winmm init %s %s (%x)", __DATE__, __TIME__, DLLENTRYPOINT_NAME));
     119        break;
     120    case 1 :
     121        auxOS2Close(); /* SvL: Close aux device if necessary */
     122        if(dllHandle) {
     123            UnregisterLxDll(dllHandle);
     124        }
     125        break;
     126    default  :
     127        return 0UL;
     128    }
    117129
    118          dllHandle = RegisterLxDll(hModule, OdinLibMain, (PVOID)&_Resource_PEResTab);
    119          if(dllHandle == 0)
    120            return 0UL;/* Error */
    121 
    122          dprintf(("winmm init %s %s (%x)", __DATE__, __TIME__, DLLENTRYPOINT_NAME));
    123 
    124          break;
    125       case 1 :
    126          auxOS2Close(); /* SvL: Close aux device if necessary */
    127          if(dllHandle) {
    128                 UnregisterLxDll(dllHandle);
    129          }
    130          break;
    131       default  :
    132          return 0UL;
    133    }
    134 
    135    /***********************************************************/
    136    /* A non-zero value must be returned to indicate success.  */
    137    /***********************************************************/
    138    return 1UL;
     130    /***********************************************************/
     131    /* A non-zero value must be returned to indicate success.  */
     132    /***********************************************************/
     133    return 1UL;
    139134}
    140135//******************************************************************************
  • trunk/src/winmm/waveout.cpp

    r5358 r5366  
    1 /* $Id: waveout.cpp,v 1.20 2001-03-23 16:23:45 sandervl Exp $ */
     1/* $Id: waveout.cpp,v 1.21 2001-03-24 15:40:04 sandervl Exp $ */
    22//#undef DEBUG
    33/*
     
    2828
    2929#include "waveoutdart.h"
     30#include "waveoutdaud.h"
    3031#include "misc.h"
    3132#include "winmm.h"
     
    5354  MMRESULT rc;
    5455
    55   if(pwfx == NULL)
     56    if(pwfx == NULL)
    5657        return(WAVERR_BADFORMAT);
    5758
    58   if(fdwOpen == WAVE_FORMAT_QUERY) {
     59    if(fdwOpen == WAVE_FORMAT_QUERY)
     60    {
    5961        if(DartWaveOut::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
    6062                                    pwfx->wBitsPerSample) == TRUE) {
     
    6264        }
    6365        else    return(WAVERR_BADFORMAT);
    64   }
    65 
    66   if(phwo == NULL)
     66    }
     67
     68    if(phwo == NULL)
    6769        return(MMSYSERR_INVALPARAM);
    6870
    69   *phwo = (HWAVEOUT)new DartWaveOut(pwfx, fdwOpen, dwCallback, dwInstance);
    70 
    71   if(*phwo == NULL) {
     71    if(DAudioWaveOut::isDirectAudioAvailable()) {
     72         *phwo = (HWAVEOUT)new DAudioWaveOut(pwfx, fdwOpen, dwCallback, dwInstance);
     73    }
     74    else *phwo = (HWAVEOUT)new DartWaveOut(pwfx, fdwOpen, dwCallback, dwInstance);
     75
     76    if(*phwo == NULL) {
    7277        return(MMSYSERR_NODRIVER);
    73   }
    74 
    75   rc = ((WaveOut *)*phwo)->getError();
    76   if(rc != MMSYSERR_NOERROR) {
     78    }
     79
     80    rc = ((WaveOut *)*phwo)->getError();
     81    if(rc != MMSYSERR_NOERROR) {
    7782        delete (WaveOut *)*phwo;
    7883        return(rc);
    79   }
    80   return(MMSYSERR_NOERROR);
     84    }
     85    return(MMSYSERR_NOERROR);
    8186}
    8287/******************************************************************************/
     
    8792              UINT, cbwh)
    8893{
    89   WaveOut *dwave = (WaveOut *)hwo;
    90 
    91   if(WaveOut::find(dwave) == TRUE)
    92   {
     94    WaveOut *dwave = (WaveOut *)hwo;
     95
     96    if(WaveOut::find(dwave) == TRUE)
     97    {
    9398        if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
    9499            return WAVERR_UNPREPARED;
     
    102107        dprintf(("waveOutWrite ptr %x size %d %x %x %x %x %x %x", pwh->lpData, pwh->dwBufferLength, pwh->dwBytesRecorded, pwh->dwUser, pwh->dwFlags, pwh->dwLoops, pwh->lpNext, pwh->reserved));
    103108        return(dwave->write(pwh, cbwh));
    104   }
    105   else  return(MMSYSERR_INVALHANDLE);
     109    }
     110    else  return(MMSYSERR_INVALHANDLE);
    106111}
    107112/******************************************************************************/
     
    121126              HWAVEOUT, hwaveout)
    122127{
    123   WaveOut *dwave = (WaveOut *)hwaveout;
    124 
    125   dprintf(("WINMM:waveOutBreakLoop (implemented as reset) %X\n", hwaveout));
    126   if(WaveOut::find(dwave) == TRUE)
    127         return(dwave->reset());
    128   else return(MMSYSERR_INVALHANDLE);
     128    WaveOut *dwave = (WaveOut *)hwaveout;
     129
     130    dprintf(("WINMM:waveOutBreakLoop (implemented as reset) %X\n", hwaveout));
     131    if(WaveOut::find(dwave) == TRUE)
     132         return(dwave->reset());
     133    else return(MMSYSERR_INVALHANDLE);
    129134}
    130135/******************************************************************************/
     
    133138              HWAVEOUT, hwaveout)
    134139{
    135   WaveOut *dwave = (WaveOut *)hwaveout;
    136 
    137   if(WaveOut::find(dwave) == TRUE)
    138   {
     140    WaveOut *dwave = (WaveOut *)hwaveout;
     141
     142    if(WaveOut::find(dwave) == TRUE)
     143    {
    139144        if(dwave->getState() == STATE_PLAYING)
    140145            return(WAVERR_STILLPLAYING);
     
    142147        delete dwave;
    143148        return(MMSYSERR_NOERROR);
    144   }
    145   else  return(MMSYSERR_INVALHANDLE);
     149    }
     150    else  return(MMSYSERR_INVALHANDLE);
    146151}
    147152/******************************************************************************/
     
    150155              HWAVEOUT, hwaveout)
    151156{
    152   WaveOut *dwave = (WaveOut *)hwaveout;
    153 
    154   if(WaveOut::find(dwave) == TRUE)
     157    WaveOut *dwave = (WaveOut *)hwaveout;
     158
     159    if(WaveOut::find(dwave) == TRUE)
    155160        return(dwave->pause());
    156   else  return(MMSYSERR_INVALHANDLE);
     161    else  return(MMSYSERR_INVALHANDLE);
    157162}
    158163/******************************************************************************/
     
    161166              HWAVEOUT, hwaveout)
    162167{
    163   WaveOut *dwave = (WaveOut *)hwaveout;
    164 
    165   if(WaveOut::find(dwave) == TRUE)
    166         return(dwave->restart());
    167   else return(MMSYSERR_INVALHANDLE);
     168    WaveOut *dwave = (WaveOut *)hwaveout;
     169
     170    if(WaveOut::find(dwave) == TRUE)
     171         return(dwave->restart());
     172    else return(MMSYSERR_INVALHANDLE);
    168173}
    169174/******************************************************************************/
     
    174179              UINT, cbwh)
    175180{
    176   WaveOut *dwave = (WaveOut *)hwo;
    177 
    178   if(WaveOut::find(dwave) == TRUE)
    179   {
     181    WaveOut *dwave = (WaveOut *)hwo;
     182
     183    if(WaveOut::find(dwave) == TRUE)
     184    {
    180185        if(pwh->dwFlags & WHDR_INQUEUE)
    181186            return WAVERR_STILLPLAYING;
     
    185190        pwh->lpNext   = NULL;
    186191        return(MMSYSERR_NOERROR);
    187   }
    188   else  return(MMSYSERR_INVALHANDLE);
     192    }
     193    else  return(MMSYSERR_INVALHANDLE);
    189194}
    190195/******************************************************************************/
     
    195200              UINT, cbwh)
    196201{
    197   WaveOut *dwave = (WaveOut *)hwo;
    198 
    199   if(WaveOut::find(dwave) == TRUE)
    200   {
     202    WaveOut *dwave = (WaveOut *)hwo;
     203
     204    if(WaveOut::find(dwave) == TRUE)
     205    {
    201206        if(pwh->dwFlags & WHDR_INQUEUE)
    202207            return WAVERR_STILLPLAYING;
     
    205210        pwh->dwFlags |= WHDR_DONE;
    206211        return(MMSYSERR_NOERROR);
    207   }
    208   else  return(MMSYSERR_INVALHANDLE);
     212    }
     213    else  return(MMSYSERR_INVALHANDLE);
    209214}
    210215/******************************************************************************/
     
    217222  WaveOut *dwave = (WaveOut *)hwo;
    218223
    219   if(pmmt == NULL)
     224    if(pmmt == NULL)
    220225        return MMSYSERR_INVALPARAM;
    221226
    222   if(WaveOut::find(dwave) == TRUE)
    223   {
    224    ULONG position;
     227    if(WaveOut::find(dwave) == TRUE)
     228    {
     229        ULONG position;
    225230
    226231        position = dwave->getPosition();
     
    260265        }
    261266        return MMSYSERR_NOERROR;
    262   }
    263   else  return(MMSYSERR_INVALHANDLE);
     267    }
     268    else  return(MMSYSERR_INVALHANDLE);
    264269}
    265270/******************************************************************************/
     
    270275              UINT, cbwoc)
    271276{
    272   if(WaveOut::getNumDevices() == 0) {
     277    if(WaveOut::getNumDevices() == 0) {
    273278        memset(pwoc, 0, sizeof(*pwoc));
    274279        return MMSYSERR_NODRIVER;
    275   }
    276 
    277   // we have to fill in this thing
    278   pwoc->wMid = 0;                  /* manufacturer ID */
    279   pwoc->wPid = 0;                  /* product ID */
    280   pwoc->vDriverVersion = 0x0001;        /* version of the driver */
    281   strcpy( pwoc->szPname, "OS/2 DART Wave Out" ); /* product name */
    282   pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
    283                     WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
    284                     WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
    285                     WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
    286                     WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
    287                     WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
    288 
    289   pwoc->wChannels  = 2;             /* number of sources supported */
    290   pwoc->wReserved1 = 0;             /* packing */
    291   pwoc->dwSupport  = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
    292 
    293   return MMSYSERR_NOERROR;
     280    }
     281
     282    // we have to fill in this thing
     283    pwoc->wMid = 0;                  /* manufacturer ID */
     284    pwoc->wPid = 0;                  /* product ID */
     285    pwoc->vDriverVersion = 0x0001;        /* version of the driver */
     286    strcpy( pwoc->szPname, "OS/2 DART Wave Out" ); /* product name */
     287    pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
     288                      WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
     289                      WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
     290                      WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
     291                      WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
     292                      WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
     293
     294    pwoc->wChannels  = 2;             /* number of sources supported */
     295    pwoc->wReserved1 = 0;             /* packing */
     296    pwoc->dwSupport  = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
     297
     298    return MMSYSERR_NOERROR;
    294299}
    295300/******************************************************************************/
     
    300305              UINT, cbwoc)
    301306{
    302   if(WaveOut::getNumDevices() == 0) {
     307    if(WaveOut::getNumDevices() == 0) {
    303308        memset(pwoc, 0, sizeof(*pwoc));
    304309        return MMSYSERR_NODRIVER;
    305   }
    306   // we have to fill in this thing
    307   pwoc->wMid = 0;                  /* manufacturer ID */
    308   pwoc->wPid = 0;                  /* product ID */
    309   pwoc->vDriverVersion = 0x0001;        /* version of the driver */
    310   lstrcpyW(pwoc->szPname, (LPCWSTR)L"OS/2 DART Wave Out"); /* product name */
    311   pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
    312                     WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
    313                     WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
    314                     WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
    315                     WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
    316                     WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
    317 
    318   pwoc->wChannels  = 2;             /* number of sources supported */
    319   pwoc->wReserved1 = 0;             /* packing */
    320   pwoc->dwSupport  = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
    321 
    322   return MMSYSERR_NOERROR;
     310    }
     311    // we have to fill in this thing
     312    pwoc->wMid = 0;                  /* manufacturer ID */
     313    pwoc->wPid = 0;                  /* product ID */
     314    pwoc->vDriverVersion = 0x0001;        /* version of the driver */
     315    lstrcpyW(pwoc->szPname, (LPCWSTR)L"OS/2 DART Wave Out"); /* product name */
     316    pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
     317                      WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
     318                      WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
     319                      WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
     320                      WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
     321                      WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
     322
     323    pwoc->wChannels  = 2;             /* number of sources supported */
     324    pwoc->wReserved1 = 0;             /* packing */
     325    pwoc->dwSupport  = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
     326
     327    return MMSYSERR_NOERROR;
    323328}
    324329/******************************************************************************/
     
    335340              UINT, cchText)
    336341{
    337   char * theMsg = getWinmmMsg( wError );
    338   if(theMsg) {
     342    char * theMsg = getWinmmMsg( wError );
     343    if(theMsg) {
    339344        strncpy( lpText, theMsg, cchText );
    340   }
    341   else
    342   {
     345    }
     346    else
     347    {
    343348        char errMsg[100];
    344349        sprintf( errMsg, "Unknown error number %d", wError );
    345350        strncpy( lpText, errMsg, cchText );
    346   }
    347   return MMSYSERR_NOERROR;
     351    }
     352    return MMSYSERR_NOERROR;
    348353}
    349354/******************************************************************************/
     
    354359              UINT, cchText)
    355360{
    356   char * theMsg = getWinmmMsg( wError );
    357   if(theMsg) {
     361    char * theMsg = getWinmmMsg( wError );
     362    if(theMsg) {
    358363        AsciiToUnicode( theMsg, lpText );
    359   }
    360   else
    361   {
     364    }
     365    else
     366    {
    362367        char errMsg[100];
    363368        sprintf( errMsg, "Unknown error number %d", wError );
    364369        AsciiToUnicode( errMsg, lpText );
    365   }
    366   return MMSYSERR_NOERROR;
     370    }
     371    return MMSYSERR_NOERROR;
    367372}
    368373/******************************************************************************/
     
    372377              LPUINT, puDeviceID)
    373378{
    374   WaveOut *dwave = (WaveOut *)hwo;
    375   if(WaveOut::find(dwave) == TRUE)
    376   {
     379    WaveOut *dwave = (WaveOut *)hwo;
     380    if(WaveOut::find(dwave) == TRUE)
     381    {
    377382        *puDeviceID = 1;
    378383        return MMSYSERR_NOERROR;
    379   }
    380   else  return(MMSYSERR_INVALHANDLE);
     384    }
     385    else  return(MMSYSERR_INVALHANDLE);
    381386}
    382387/******************************************************************************/
     
    397402              DWORD, dwPitch)
    398403{
    399   WaveOut *dwave = (WaveOut *)hwo;
    400   if(WaveOut::find(dwave) == TRUE)
    401         return MMSYSERR_NOTSUPPORTED;
    402   else return(MMSYSERR_INVALHANDLE);
     404    WaveOut *dwave = (WaveOut *)hwo;
     405    if(WaveOut::find(dwave) == TRUE)
     406         return MMSYSERR_NOTSUPPORTED;
     407    else return(MMSYSERR_INVALHANDLE);
    403408}
    404409/******************************************************************************/
  • trunk/src/winmm/waveoutdaud.cpp

    r5358 r5366  
    1 /* $Id: waveoutdaud.cpp,v 1.1 2001-03-23 16:23:46 sandervl Exp $ */
     1/* $Id: waveoutdaud.cpp,v 1.2 2001-03-24 15:40:04 sandervl Exp $ */
    22
    33/*
     
    7373
    7474    rc = DosDevIOCtl(hDAudioDrv, DAUDIO_IOCTL_CAT, DAUDIO_OPEN, NULL, 0,
    75                          &ParmLength, &init, DataLength, &DataLength);
     75                     &ParmLength, &init, DataLength, &DataLength);
    7676    if(rc) {
    7777        dprintf(("DosDevIOCtl failed with error %d\n", rc));
     
    9393    cmd.Thread.hSemaphore = hSem;
    9494    rc = DosDevIOCtl(hDAudioDrv, DAUDIO_IOCTL_CAT, DAUDIO_REGISTER_THREAD, NULL, 0,
    95                          &ParmLength, &cmd, DataLength, &DataLength);
     95                     &ParmLength, &cmd, DataLength, &DataLength);
    9696    if(rc) {
    9797        dprintf(("DosDevIOCtl failed with error %d\n", rc));
     
    337337/******************************************************************************/
    338338/******************************************************************************/
     339BOOL DAudioWaveOut::isDirectAudioAvailable()
     340{
     341    static BOOL fAvailable = FALSE;
     342    static BOOL fTested    = FALSE;
     343
     344    APIRET          rc;
     345    ULONG           action;
     346    HFILE           hDriver;
     347
     348    if(!fTested) {
     349        rc = DosOpen("DAUDIO1$", &hDriver, &action, 0,
     350                     FILE_NORMAL, FILE_OPEN, OPEN_ACCESS_READWRITE |
     351                     OPEN_SHARE_DENYNONE | OPEN_FLAGS_WRITE_THROUGH,
     352                     NULL );
     353        fTested = TRUE;
     354        if(rc) {
     355            return FALSE;
     356        }
     357        DosClose(hDriver);
     358        fAvailable = TRUE;
     359    }
     360    return fAvailable;
     361
     362}
     363/******************************************************************************/
     364/******************************************************************************/
    339365MMRESULT DAudioWaveOut::setVolume(ULONG ulVol)
    340366{
     
    354380
    355381    rc = DosDevIOCtl(hDAudioDrv, DAUDIO_IOCTL_CAT, cmd, NULL, 0,
    356                          &ParmLength, pDataPacket, DataLength, &DataLength);
     382                     &ParmLength, pDataPacket, DataLength, &DataLength);
    357383    if(rc) {
    358384        dprintf(("DosDevIOCtl failed with error %d (command %d)", rc, cmd));
     
    417443            return 0;
    418444        }
    419         dwave->handler();
    420     }
    421 
    422 }
    423 /******************************************************************************/
    424 /******************************************************************************/
    425 
     445        for(int i=0;i<postcnt;i++) {
     446            dwave->handler();
     447        }
     448    }
     449
     450}
     451/******************************************************************************/
     452/******************************************************************************/
     453
  • trunk/src/winmm/waveoutdaud.h

    r5358 r5366  
    1 /* $Id: waveoutdaud.h,v 1.1 2001-03-23 16:23:47 sandervl Exp $ */
     1/* $Id: waveoutdaud.h,v 1.2 2001-03-24 15:40:04 sandervl Exp $ */
    22
    33/*
     
    1212
    1313#include "waveoutbase.h"
     14#include <daudio.h>
     15
     16#ifdef _OS2WIN_H
     17typedef DWORD HEV;
     18#endif
    1419
    1520class DAudioWaveOut : public WaveOut
     
    3035                                   ULONG nSamplesPerSec, ULONG sampleSize);
    3136
     37
     38     static   BOOL     isDirectAudioAvailable();
    3239
    3340protected:
Note: See TracChangeset for help on using the changeset viewer.