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

Enabled DirectAudio wave playback interface (if present)

File:
1 edited

Legend:

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