Ignore:
Timestamp:
Feb 27, 2001, 10:14:00 PM (24 years ago)
Author:
sandervl
Message:

Added preliminary wavein support

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/wavein.cpp

    r2812 r5272  
    1 /* $Id: wavein.cpp,v 1.5 2000-02-17 14:09:32 sandervl Exp $ */
     1/* $Id: wavein.cpp,v 1.6 2001-02-27 21:13:59 sandervl Exp $ */
    22
    33/*
    … …  
    2525
    2626#include "winmm.h"
    27 
    28 #define DBG_LOCALLOG    DBG_wavein
     27#include "dwavein.h"
     28
     29#define DBG_LOCALLOG    DBG_wavein
    2930#include "dbglocal.h"
    3031
    … …  
    3233ODINDEBUGCHANNEL(WINMM-WAVEIN)
    3334
    34 // All stubs for now
    35 ODINFUNCTION3(MMRESULT, waveInAddBuffer,
    36               HWAVEIN, hwi,
    37               LPWAVEHDR, pwh,
    38               UINT, cbwh)
    39 {
    40   dprintf(("WINMM:waveInAddBuffer - stub\n"));
    41   return MMSYSERR_INVALHANDLE;
    42 }
    43 
    44 ODINFUNCTION1(MMRESULT, waveInClose,
    45               HWAVEIN, hwi)
    46 {
    47   dprintf(("WINMM:waveInClose - stub\n"));
    48   return MMSYSERR_INVALHANDLE;
    49 }
    50 
    51 ODINFUNCTION3(MMRESULT, waveInGetDevCapsA,
    52               UINT, uDeviceID,
    53               LPWAVEINCAPSA, pwic,
    54               UINT, cbwic)
    55 {
    56   dprintf(("WINMM:waveInGetDevCapsA(%d) - stub\n", uDeviceID ));
    57   return MMSYSERR_BADDEVICEID;
    58 }
    59 
    60 ODINFUNCTION3(MMRESULT, waveInGetDevCapsW,
    61               UINT, uDeviceID,
    62               LPWAVEINCAPSW, pwic,
    63               UINT, cbwic)
    64 {
    65   dprintf(("WINMM:waveInGetDevCapsW(%d) - stub\n", uDeviceID ));
    66   return MMSYSERR_BADDEVICEID;
    67 }
    68 
    69 ODINFUNCTION3(MMRESULT, waveInGetErrorTextA,
    70               MMRESULT, wError,
    71               LPSTR, lpText,
    72               UINT, cchText)
    73 {
    74   dprintf(("WINMM:waveInGetErrorTextA(%d)\n", wError ));
    75   char * theMsg = getWinmmMsg( wError );
    76   if ( theMsg )
    77     strncpy( lpText, theMsg, cchText );
    78   else
    79   {
    80     char errMsg[100];
    81     sprintf( errMsg, "Unknown error number %d", wError );
    82     strncpy( lpText, errMsg, cchText );
    83   }
    84   return MMSYSERR_NOERROR;
    85 }
    86 
    87 ODINFUNCTION3(MMRESULT, waveInGetErrorTextW,
    88               MMRESULT, wError,
    89               LPWSTR, lpText,
    90               UINT, cchText)
    91 {
    92   dprintf(("WINMM:waveInGetErrorTextW(%d) - stub\n", wError ));
    93   char * theMsg = getWinmmMsg( wError );
    94   if ( theMsg )
    95     AsciiToUnicode( theMsg, lpText );
    96   else
    97   {
    98     char errMsg[100];
    99     sprintf( errMsg, "Unknown error number %d", wError );
    100     AsciiToUnicode( errMsg, lpText );
    101   }
    102   return MMSYSERR_NOERROR;
    103 }
    104 
    105 ODINFUNCTION2(MMRESULT, waveInGetID,
    106               HWAVEIN, hwi,
    107               LPUINT, puDeviceID)
    108 {
    109   dprintf(("WINMM:waveInGetID - stub\n"));
    110   return MMSYSERR_INVALHANDLE;
    111 }
    112 
    113 ODINFUNCTION0(UINT, waveInGetNumDevs)
    114 {
    115   dprintf(("WINMM:waveInGetNumDevs - stub\n"));
    116   return 0;
    117 }
    118 
    119 ODINFUNCTION3(MMRESULT, waveInGetPosition,
    120               HWAVEIN, hwi,
    121               LPMMTIME, pmmt,
    122               UINT, cbmmt)
    123 {
    124   dprintf(("WINMM:waveInGetPosition - stub\n"));
    125   return MMSYSERR_INVALHANDLE;
    126 }
    127 
    128 ODINFUNCTION4(MMRESULT, waveInMessage,
    129               HWAVEIN, hwi,
    130               UINT, uMsg,
    131               DWORD, dw1,
    132               DWORD, dw2)
    133 {
    134   dprintf(("WINMM:waveInMessage - stub\n"));
    135   return MMSYSERR_INVALHANDLE;
    136 }
    137 
    138 
     35/******************************************************************************/
     36/******************************************************************************/
    13937ODINFUNCTION6(MMRESULT, waveInOpen,
    14038              LPHWAVEIN, phwi,
    … …  
    14543              DWORD, fdwOpen)
    14644{
    147   dprintf(("WINMM:waveInOpen - stub\n"));
    148    return MMSYSERR_BADDEVICEID;
    149 }
    150 
    151 ODINFUNCTION3(MMRESULT, waveInPrepareHeader,
     45  MMRESULT rc;
     46
     47  if(pwfx == NULL)
     48        return(WAVERR_BADFORMAT);
     49
     50  if(fdwOpen == WAVE_FORMAT_QUERY) {
     51        if(DartWaveIn::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
     52                                   pwfx->wBitsPerSample) == TRUE) {
     53                return(MMSYSERR_NOERROR);
     54        }
     55        else    return(WAVERR_BADFORMAT);
     56  }
     57
     58  if(phwi == NULL)
     59        return(MMSYSERR_INVALPARAM);
     60
     61  if(fdwOpen == CALLBACK_WINDOW) {
     62        *phwi = (HWAVEOUT)new DartWaveIn(pwfx, (HWND)dwCallback);
     63  }
     64  else
     65  if(fdwOpen == CALLBACK_FUNCTION)
     66  {
     67        //@@@PH 1999/12/28 save valid FS: to win32 TIB
     68        *phwi = (HWAVEOUT)new DartWaveIn(pwfx, dwCallback, dwInstance, GetFS());
     69  }
     70  else  *phwi = (HWAVEOUT)new DartWaveIn(pwfx);
     71
     72  if(*phwi == NULL) {
     73        return(MMSYSERR_NODRIVER);
     74  }
     75
     76  rc = ((DartWaveIn *)*phwi)->getError();
     77  if(rc != MMSYSERR_NOERROR) {
     78        delete (DartWaveIn *)*phwi;
     79        return(rc);
     80  }
     81  return(MMSYSERR_NOERROR);
     82}
     83/******************************************************************************/
     84/******************************************************************************/
     85ODINFUNCTION1(MMRESULT, waveInClose,
     86              HWAVEIN, hwi)
     87{
     88  DartWaveIn *dwave = (DartWaveIn *)hwi;
     89
     90  if(DartWaveIn::find(dwave) == TRUE)
     91  {
     92        if(dwave->getState() == STATE_RECORDING)
     93            return(WAVERR_STILLPLAYING);
     94
     95        delete dwave;
     96        return(MMSYSERR_NOERROR);
     97  }
     98  else  return(MMSYSERR_INVALHANDLE);
     99}
     100/******************************************************************************/
     101/******************************************************************************/
     102ODINFUNCTION1(MMRESULT, waveInReset,
     103              HWAVEIN, hwi)
     104{
     105  DartWaveIn *dwave = (DartWaveIn *)hwi;
     106
     107  if(DartWaveIn::find(dwave) == TRUE)
     108        return(dwave->reset());
     109  else  return(MMSYSERR_INVALHANDLE);
     110}
     111/******************************************************************************/
     112/******************************************************************************/
     113ODINFUNCTION1(MMRESULT, waveInStart,
     114              HWAVEIN, hwi)
     115{
     116  DartWaveIn *dwave = (DartWaveIn *)hwi;
     117
     118  if(DartWaveIn::find(dwave) == TRUE)
     119        return(dwave->start());
     120  else  return(MMSYSERR_INVALHANDLE);
     121}
     122/******************************************************************************/
     123/******************************************************************************/
     124ODINFUNCTION1(MMRESULT, waveInStop,
     125              HWAVEIN, hwi)
     126{
     127  DartWaveIn *dwave = (DartWaveIn *)hwi;
     128
     129  if(DartWaveIn::find(dwave) == TRUE)
     130        return(dwave->stop());
     131  else  return(MMSYSERR_INVALHANDLE);
     132}
     133/******************************************************************************/
     134/******************************************************************************/
     135ODINFUNCTION3(MMRESULT, waveInGetPosition,
     136              HWAVEIN, hwi,
     137              LPMMTIME, pmmt,
     138              UINT, cbmmt)
     139{
     140  DartWaveIn *dwave = (DartWaveIn *)hwi;
     141
     142  if(pmmt == NULL)
     143        return MMSYSERR_INVALPARAM;
     144
     145  if(DartWaveIn::find(dwave) == TRUE)
     146  {
     147    ULONG position;
     148
     149        position = dwave->getPosition();
     150        if(position == -1) {
     151            return MMSYSERR_HANDLEBUSY; //todo correct error value
     152        }
     153        switch (pmmt->wType) {
     154        case TIME_BYTES:
     155            pmmt->u.cb = position;
     156            break;
     157        case TIME_SAMPLES:
     158            pmmt->u.sample = position * 8 / dwave->getBitsPerSample();
     159            break;
     160        case TIME_SMPTE:
     161        {
     162            ULONG timeval = position / (dwave->getAvgBytesPerSecond() / 1000);
     163            pmmt->u.smpte.hour = timeval / 108000;
     164            timeval -= pmmt->u.smpte.hour * 108000;
     165            pmmt->u.smpte.min = timeval / 1800;
     166            timeval -= pmmt->u.smpte.min * 1800;
     167            pmmt->u.smpte.sec = timeval / 30;
     168            timeval -= pmmt->u.smpte.sec * 30;
     169            pmmt->u.smpte.frame = timeval;
     170            pmmt->u.smpte.fps = 30;
     171            break;
     172        }
     173        default:
     174            dprintf(("waveInGetPosition: Format %d not supported ! use TIME_MS !\n", pmmt->wType));
     175            pmmt->wType = TIME_MS;
     176        case TIME_MS:
     177            pmmt->u.ms = position / (dwave->getAvgBytesPerSecond() / 1000);
     178            dprintf(("WINMM:waveInGetPosition: TIME_MS pos=%d ms=%d time=%d", position, pmmt->u.ms, GetCurrentTime()));
     179            break;
     180        }
     181        return MMSYSERR_NOERROR;
     182  }
     183  else  return(MMSYSERR_INVALHANDLE);
     184}
     185/******************************************************************************/
     186/******************************************************************************/
     187ODINFUNCTION3(MMRESULT, waveInAddBuffer,
    152188              HWAVEIN, hwi,
    153189              LPWAVEHDR, pwh,
    154190              UINT, cbwh)
    155191{
    156   dprintf(("WINMM:waveInPrepareHeader - stub\n"));
    157   return MMSYSERR_INVALHANDLE;
    158 }
    159 
    160 ODINFUNCTION1(MMRESULT, waveInReset,
    161               HWAVEIN, hwi)
    162 {
    163   dprintf(("WINMM:waveInReset - stub\n"));
    164   return MMSYSERR_INVALHANDLE;
    165 }
    166 
    167 ODINFUNCTION1(MMRESULT, waveInStart,
    168               HWAVEIN, hwi)
    169 {
    170   dprintf(("WINMM:waveInStart - stub\n"));
    171   return MMSYSERR_INVALHANDLE;
    172 }
    173 
    174 ODINFUNCTION1(MMRESULT, waveInStop,
    175               HWAVEIN, hwi)
    176 {
    177   dprintf(("WINMM:waveInStop - stub\n"));
    178   return MMSYSERR_INVALHANDLE;
    179 }
    180 
    181 ODINFUNCTION3(MMRESULT, waveInUnprepareHeader,
     192    DartWaveIn *dwave = (DartWaveIn *)hwi;
     193
     194    if(DartWaveIn::find(dwave) == TRUE)
     195    {
     196        if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
     197            return WAVERR_UNPREPARED;
     198
     199        if(pwh->dwFlags & WHDR_INQUEUE)
     200            return WAVERR_STILLPLAYING;
     201
     202        pwh->dwFlags |= WHDR_INQUEUE;
     203        pwh->dwFlags &= ~WHDR_DONE;
     204
     205        dprintf(("waveInAddBuffer %x %d %x", pwh->lpData, pwh->dwBufferLength, pwh->dwFlags));
     206        return(dwave->addBuffer(pwh, cbwh));
     207    }
     208    else  return(MMSYSERR_INVALHANDLE);
     209}
     210/******************************************************************************/
     211/******************************************************************************/
     212ODINFUNCTION3(MMRESULT, waveInPrepareHeader,
    182213              HWAVEIN, hwi,
    183214              LPWAVEHDR, pwh,
    184215              UINT, cbwh)
    185216{
    186   dprintf(("WINMM:waveInUnprepareHeader - stub\n"));
    187   return MMSYSERR_INVALHANDLE;
    188 }
    189 
    190 
     217    DartWaveIn *dwave = (DartWaveIn *)hwi;
     218
     219    if(DartWaveIn::find(dwave) == TRUE)
     220    {
     221        if(pwh->dwFlags & WHDR_INQUEUE)
     222            return WAVERR_STILLPLAYING;
     223
     224        pwh->dwFlags |= WHDR_PREPARED;
     225        pwh->dwFlags &= ~WHDR_DONE;
     226        pwh->lpNext   = NULL;
     227        return(MMSYSERR_NOERROR);
     228    }
     229    else  return(MMSYSERR_INVALHANDLE);
     230}
     231/******************************************************************************/
     232/******************************************************************************/
     233ODINFUNCTION3(MMRESULT, waveInUnprepareHeader,
     234              HWAVEIN, hwi,
     235              LPWAVEHDR, pwh,
     236              UINT, cbwh)
     237{
     238    DartWaveIn *dwave = (DartWaveIn *)hwi;
     239
     240    if(DartWaveIn::find(dwave) == TRUE)
     241    {
     242        if(pwh->dwFlags & WHDR_INQUEUE)
     243            return WAVERR_STILLPLAYING;
     244
     245        pwh->dwFlags &= ~WHDR_PREPARED;
     246        pwh->dwFlags |= WHDR_DONE;
     247        return(MMSYSERR_NOERROR);
     248    }
     249    else  return(MMSYSERR_INVALHANDLE);
     250}
     251/******************************************************************************/
     252/******************************************************************************/
     253ODINFUNCTION3(MMRESULT, waveInGetDevCapsA,
     254              UINT, uDeviceID,
     255              LPWAVEINCAPSA, pwic,
     256              UINT, cbwic)
     257{
     258    if(DartWaveIn::getNumDevices() == 0) {
     259        memset(pwic, 0, sizeof(*pwic));
     260        return MMSYSERR_NODRIVER;
     261    }
     262
     263    // we have to fill in this thing
     264    pwic->wMid = 0;                  /* manufacturer ID */
     265    pwic->wPid = 0;                  /* product ID */
     266    pwic->vDriverVersion = 0x0001;        /* version of the driver */
     267    strcpy( pwic->szPname, "OS/2 DART Wave In" ); /* product name */
     268    pwic->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
     269                      WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
     270                      WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
     271                      WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
     272                      WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
     273                      WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
     274
     275    pwic->wChannels  = 2;             /* number of sources supported */
     276    pwic->wReserved1 = 0;             /* packing */
     277
     278    return MMSYSERR_NOERROR;
     279}
     280/******************************************************************************/
     281/******************************************************************************/
     282ODINFUNCTION3(MMRESULT, waveInGetDevCapsW,
     283              UINT, uDeviceID,
     284              LPWAVEINCAPSW, pwic,
     285              UINT, cbwic)
     286{
     287    if(DartWaveIn::getNumDevices() == 0) {
     288        memset(pwic, 0, sizeof(*pwic));
     289        return MMSYSERR_NODRIVER;
     290    }
     291    // we have to fill in this thing
     292    pwic->wMid = 0;                  /* manufacturer ID */
     293    pwic->wPid = 0;                  /* product ID */
     294    pwic->vDriverVersion = 0x0001;        /* version of the driver */
     295    lstrcpyW(pwic->szPname, (LPCWSTR)L"OS/2 DART Wave In"); /* product name */
     296    pwic->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
     297                      WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
     298                      WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
     299                      WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
     300                      WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
     301                      WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
     302
     303    pwic->wChannels  = 2;             /* number of sources supported */
     304    pwic->wReserved1 = 0;             /* packing */
     305
     306    return MMSYSERR_NOERROR;
     307}
     308/******************************************************************************/
     309/******************************************************************************/
     310ODINFUNCTION3(MMRESULT, waveInGetErrorTextA,
     311              MMRESULT, wError,
     312              LPSTR, lpText,
     313              UINT, cchText)
     314{
     315    dprintf(("WINMM:waveInGetErrorTextA(%d)\n", wError ));
     316    char * theMsg = getWinmmMsg( wError );
     317    if ( theMsg )
     318        strncpy( lpText, theMsg, cchText );
     319    else
     320    {
     321        char errMsg[100];
     322        sprintf( errMsg, "Unknown error number %d", wError );
     323        strncpy( lpText, errMsg, cchText );
     324    }
     325    return MMSYSERR_NOERROR;
     326}
     327/******************************************************************************/
     328/******************************************************************************/
     329ODINFUNCTION3(MMRESULT, waveInGetErrorTextW,
     330              MMRESULT, wError,
     331              LPWSTR, lpText,
     332              UINT, cchText)
     333{
     334    dprintf(("WINMM:waveInGetErrorTextW(%d) - stub\n", wError ));
     335    char * theMsg = getWinmmMsg( wError );
     336    if ( theMsg )
     337        AsciiToUnicode( theMsg, lpText );
     338    else
     339    {
     340        char errMsg[100];
     341        sprintf( errMsg, "Unknown error number %d", wError );
     342        AsciiToUnicode( errMsg, lpText );
     343    }
     344    return MMSYSERR_NOERROR;
     345}
     346/******************************************************************************/
     347/******************************************************************************/
     348ODINFUNCTION2(MMRESULT, waveInGetID,
     349              HWAVEIN, hwi,
     350              LPUINT, puDeviceID)
     351{
     352    DartWaveIn *dwave = (DartWaveIn *)hwi;
     353    if(DartWaveIn::find(dwave) == TRUE)
     354    {
     355        *puDeviceID = 1;
     356        return MMSYSERR_NOERROR;
     357    }
     358    else  return(MMSYSERR_INVALHANDLE);
     359}
     360/******************************************************************************/
     361/******************************************************************************/
     362ODINFUNCTION0(UINT, waveInGetNumDevs)
     363{
     364    return DartWaveIn::getNumDevices();
     365}
     366/******************************************************************************/
     367/******************************************************************************/
     368ODINFUNCTION4(MMRESULT, waveInMessage,
     369              HWAVEIN, hwi,
     370              UINT, uMsg,
     371              DWORD, dw1,
     372              DWORD, dw2)
     373{
     374    dprintf(("WINMM:waveInMessage - stub\n"));
     375
     376    DartWaveIn *dwave = (DartWaveIn *)hwi;
     377    if(DartWaveIn::find(dwave) == TRUE)
     378    {
     379        return MMSYSERR_NOTSUPPORTED;
     380    }
     381    else
     382        return(MMSYSERR_INVALHANDLE);
     383}
     384/******************************************************************************/
     385/******************************************************************************/
     386
Note: See TracChangeset for help on using the changeset viewer.