Ignore:
Timestamp:
Feb 27, 2000, 9:29:47 PM (25 years ago)
Author:
sandervl
Message:

Implemented waveOutGetPosition

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/waveout.cpp

    r2812 r2935  
    1 /* $Id: waveout.cpp,v 1.10 2000-02-17 14:09:33 sandervl Exp $ */
     1/* $Id: waveout.cpp,v 1.11 2000-02-27 20:29:47 sandervl Exp $ */
    22//#undef DEBUG
    33/*
    44 * Wave out MM apis
    55 *
    6  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
     6 * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
    77 *
     8 * waveOutGetPosition partly based on Wine code (dll\winmm\wineoss\audio.c)
     9 * Copyright 1994 Martin Ayotte
    810 *
    911 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    2931#include "winmm.h"
    3032
    31 #define DBG_LOCALLOG    DBG_waveout
     33#define DBG_LOCALLOG    DBG_waveout
    3234#include "dbglocal.h"
    3335
    … …  
    98100  if(DartWaveOut::find(dwave) == TRUE)
    99101  {
    100     if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
    101       return WAVERR_UNPREPARED;
    102 
    103     if(pwh->dwFlags & WHDR_INQUEUE)
    104       return WAVERR_STILLPLAYING;
    105 
    106     pwh->dwFlags |= WHDR_INQUEUE;
    107     pwh->dwFlags &= ~WHDR_DONE;
    108 
    109     return(dwave->write(pwh, cbwh));
    110   }
    111   else
    112     return(MMSYSERR_INVALHANDLE);
     102        if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
     103            return WAVERR_UNPREPARED;
     104
     105        if(pwh->dwFlags & WHDR_INQUEUE)
     106            return WAVERR_STILLPLAYING;
     107
     108        pwh->dwFlags |= WHDR_INQUEUE;
     109        pwh->dwFlags &= ~WHDR_DONE;
     110
     111        return(dwave->write(pwh, cbwh));
     112  }
     113  else  return(MMSYSERR_INVALHANDLE);
    113114}
    114115/******************************************************************************/
    … …  
    120121
    121122  if(DartWaveOut::find(dwave) == TRUE)
    122     return(dwave->reset());
    123   else
    124     return(MMSYSERR_INVALHANDLE);
     123        return(dwave->reset());
     124  else  return(MMSYSERR_INVALHANDLE);
    125125}
    126126/******************************************************************************/
    … …  
    133133  dprintf(("WINMM:waveOutBreakLoop (implemented as reset) %X\n", hwaveout));
    134134  if(DartWaveOut::find(dwave) == TRUE)
    135     return(dwave->reset());
    136   else
    137     return(MMSYSERR_INVALHANDLE);
     135        return(dwave->reset());
     136  else  return(MMSYSERR_INVALHANDLE);
    138137}
    139138/******************************************************************************/
    … …  
    146145  if(DartWaveOut::find(dwave) == TRUE)
    147146  {
    148     if(dwave->getState() == STATE_PLAYING)
    149       return(WAVERR_STILLPLAYING);
    150 
    151     delete dwave;
    152     return(MMSYSERR_NOERROR);
    153   }
    154   else
    155     return(MMSYSERR_INVALHANDLE);
     147        if(dwave->getState() == STATE_PLAYING)
     148            return(WAVERR_STILLPLAYING);
     149
     150        delete dwave;
     151        return(MMSYSERR_NOERROR);
     152  }
     153  else  return(MMSYSERR_INVALHANDLE);
    156154}
    157155/******************************************************************************/
    … …  
    163161
    164162  if(DartWaveOut::find(dwave) == TRUE)
    165     return(dwave->pause());
    166   else
    167     return(MMSYSERR_INVALHANDLE);
     163        return(dwave->pause());
     164  else  return(MMSYSERR_INVALHANDLE);
    168165}
    169166/******************************************************************************/
    … …  
    175172
    176173  if(DartWaveOut::find(dwave) == TRUE)
    177     return(dwave->restart());
    178   else
    179     return(MMSYSERR_INVALHANDLE);
     174        return(dwave->restart());
     175  else  return(MMSYSERR_INVALHANDLE);
    180176}
    181177/******************************************************************************/
    … …  
    190186  if(DartWaveOut::find(dwave) == TRUE)
    191187  {
    192     if(pwh->dwFlags & WHDR_INQUEUE)
    193       return WAVERR_STILLPLAYING;
    194 
    195     pwh->dwFlags |= WHDR_PREPARED;
    196     pwh->dwFlags &= ~WHDR_DONE;
    197     pwh->lpNext   = NULL;
    198     return(MMSYSERR_NOERROR);
    199   }
    200   else
    201     return(MMSYSERR_INVALHANDLE);
     188        if(pwh->dwFlags & WHDR_INQUEUE)
     189            return WAVERR_STILLPLAYING;
     190
     191        pwh->dwFlags |= WHDR_PREPARED;
     192        pwh->dwFlags &= ~WHDR_DONE;
     193        pwh->lpNext   = NULL;
     194        return(MMSYSERR_NOERROR);
     195  }
     196  else  return(MMSYSERR_INVALHANDLE);
    202197}
    203198/******************************************************************************/
    … …  
    212207  if(DartWaveOut::find(dwave) == TRUE)
    213208  {
    214     if(pwh->dwFlags & WHDR_INQUEUE)
    215       return WAVERR_STILLPLAYING;
    216 
    217     pwh->dwFlags &= ~WHDR_PREPARED;
    218     pwh->dwFlags |= WHDR_DONE;
    219    return(MMSYSERR_NOERROR);
    220   }
    221   else
    222    return(MMSYSERR_INVALHANDLE);
     209        if(pwh->dwFlags & WHDR_INQUEUE)
     210            return WAVERR_STILLPLAYING;
     211
     212        pwh->dwFlags &= ~WHDR_PREPARED;
     213        pwh->dwFlags |= WHDR_DONE;
     214        return(MMSYSERR_NOERROR);
     215  }
     216  else  return(MMSYSERR_INVALHANDLE);
    223217}
    224218/******************************************************************************/
    … …  
    230224{
    231225  DartWaveOut *dwave = (DartWaveOut *)hwo;
    232   dprintf(("WINMM:waveOutGetPosition - not implemented\n"));
    233   if(DartWaveOut::find(dwave) == TRUE)
    234     return(MMSYSERR_NOERROR);
    235   else
    236     return(MMSYSERR_INVALHANDLE);
     226
     227  if(pmmt == NULL)     
     228        return MMSYSERR_INVALPARAM;
     229
     230  if(DartWaveOut::find(dwave) == TRUE)
     231  {
     232   ULONG position;
     233
     234        position = dwave->getPosition();
     235        if(position == -1) {
     236            return MMSYSERR_HANDLEBUSY; //todo correct error value
     237        }
     238        switch (pmmt->wType) {
     239        case TIME_BYTES:
     240                pmmt->u.cb = position;
     241                break;
     242        case TIME_SAMPLES:
     243                pmmt->u.sample = position * 8 / dwave->getBitsPerSample();
     244                break;
     245        case TIME_SMPTE:
     246        {
     247                ULONG timeval = position / (dwave->getAvgBytesPerSecond() / 1000);
     248                pmmt->u.smpte.hour = timeval / 108000;
     249                timeval -= pmmt->u.smpte.hour * 108000;
     250                pmmt->u.smpte.min = timeval / 1800;
     251                timeval -= pmmt->u.smpte.min * 1800;
     252                pmmt->u.smpte.sec = timeval / 30;
     253                timeval -= pmmt->u.smpte.sec * 30;
     254                pmmt->u.smpte.frame = timeval;
     255                pmmt->u.smpte.fps = 30;
     256                break;
     257            }
     258        default:
     259                dprintf(("waveOutGetPosition: Format %d not supported ! use TIME_MS !\n", pmmt->wType));
     260                pmmt->wType = TIME_MS;
     261        case TIME_MS:
     262                pmmt->u.ms = position / (dwave->getAvgBytesPerSecond() / 1000);
     263                dprintf(("WINMM:waveOutGetPosition: TIME_MS pos=%d ms=%d time=%d", position, pmmt->u.ms, GetCurrentTime()));
     264                break;
     265        }
     266        return MMSYSERR_NOERROR;
     267  }
     268  else  return(MMSYSERR_INVALHANDLE);
    237269}
    238270/******************************************************************************/
    … …  
    243275              UINT, cbwoc)
    244276{
    245   dprintf(("WINMM:waveOutGetDevCapsA"));
    246 
    247277  if(DartWaveOut::getNumDevices() == 0) {
    248         memset(pwoc, 0, sizeof(*pwoc));
    249         return MMSYSERR_NODRIVER;
     278        memset(pwoc, 0, sizeof(*pwoc));
     279        return MMSYSERR_NODRIVER;
    250280  }
    251281
    … …  
    278308
    279309  if(DartWaveOut::getNumDevices() == 0) {
    280         memset(pwoc, 0, sizeof(*pwoc));
    281         return MMSYSERR_NODRIVER;
     310        memset(pwoc, 0, sizeof(*pwoc));
     311        return MMSYSERR_NODRIVER;
    282312  }
    283313  // we have to fill in this thing
    … …  
    313343{
    314344  char * theMsg = getWinmmMsg( wError );
    315   if ( theMsg )
    316     strncpy( lpText, theMsg, cchText );
    317   else
    318   {
    319     char errMsg[100];
    320     sprintf( errMsg, "Unknown error number %d", wError );
    321     strncpy( lpText, errMsg, cchText );
     345  if(theMsg) {
     346        strncpy( lpText, theMsg, cchText );
     347  }
     348  else
     349  {
     350        char errMsg[100];
     351        sprintf( errMsg, "Unknown error number %d", wError );
     352        strncpy( lpText, errMsg, cchText );
    322353  }
    323354  return MMSYSERR_NOERROR;
    324355}
    325 
     356/******************************************************************************/
     357/******************************************************************************/
    326358ODINFUNCTION3(MMRESULT, waveOutGetErrorTextW,
    327359              MMRESULT, wError,
    … …  
    330362{
    331363  char * theMsg = getWinmmMsg( wError );
    332   if ( theMsg )
    333     AsciiToUnicode( theMsg, lpText );
    334   else
    335   {
    336     char errMsg[100];
    337     sprintf( errMsg, "Unknown error number %d", wError );
    338     AsciiToUnicode( errMsg, lpText );
     364  if(theMsg) {
     365        AsciiToUnicode( theMsg, lpText );
     366  }
     367  else
     368  {
     369        char errMsg[100];
     370        sprintf( errMsg, "Unknown error number %d", wError );
     371        AsciiToUnicode( errMsg, lpText );
    339372  }
    340373  return MMSYSERR_NOERROR;
    341374}
    342 
     375/******************************************************************************/
     376/******************************************************************************/
    343377ODINFUNCTION2(MMRESULT, waveOutGetID,
    344378              HWAVEOUT, hwo,
    … …  
    348382  if(DartWaveOut::find(dwave) == TRUE)
    349383  {
    350     *puDeviceID = 1;
    351     return MMSYSERR_NOERROR;
    352   }
    353   else
    354     return(MMSYSERR_INVALHANDLE);
    355 }
    356 
     384        *puDeviceID = 1;
     385        return MMSYSERR_NOERROR;
     386  }
     387  else  return(MMSYSERR_INVALHANDLE);
     388}
     389/******************************************************************************/
     390/******************************************************************************/
    357391ODINFUNCTION2(MMRESULT, waveOutGetPitch,
    358392              HWAVEOUT, hwo,
    … …  
    361395  DartWaveOut *dwave = (DartWaveOut *)hwo;
    362396  if(DartWaveOut::find(dwave) == TRUE)
    363     return MMSYSERR_NOTSUPPORTED;
    364   else
    365     return(MMSYSERR_INVALHANDLE);
    366 }
    367 
     397        return MMSYSERR_NOTSUPPORTED;
     398  else  return(MMSYSERR_INVALHANDLE);
     399}
     400/******************************************************************************/
     401/******************************************************************************/
    368402ODINFUNCTION2(MMRESULT, waveOutSetPitch,
    369403              HWAVEOUT, hwo,
    … …  
    372406  DartWaveOut *dwave = (DartWaveOut *)hwo;
    373407  if(DartWaveOut::find(dwave) == TRUE)
    374     return MMSYSERR_NOTSUPPORTED;
    375   else
    376     return(MMSYSERR_INVALHANDLE);
    377 }
    378 
     408        return MMSYSERR_NOTSUPPORTED;
     409  else  return(MMSYSERR_INVALHANDLE);
     410}
     411/******************************************************************************/
     412/******************************************************************************/
    379413ODINFUNCTION2(MMRESULT, waveOutGetVolume,
    380414              HWAVEOUT, hwo,
    … …  
    384418  if(DartWaveOut::find(dwave) == TRUE)
    385419  {
    386     if (pdwVolume!=NULL)
    387       *pdwVolume=dwave->getVolume();
    388     return MMSYSERR_NOERROR;   
     420        if(pdwVolume!=NULL)
     421            *pdwVolume=dwave->getVolume();
     422        return MMSYSERR_NOERROR;
    389423  }
    390424  else
    … …  
    392426//    return(MMSYSERR_INVALHANDLE);
    393427}
    394 
     428/******************************************************************************/
     429/******************************************************************************/
    395430ODINFUNCTION2(MMRESULT, waveOutSetVolume,
    396431              HWAVEOUT, hwo,
    … …  
    406441//    return(MMSYSERR_INVALHANDLE);
    407442}
    408 
     443/******************************************************************************/
     444/******************************************************************************/
    409445ODINFUNCTION2(MMRESULT, waveOutGetPlaybackRate,
    410446              HWAVEOUT, hwo,
    … …  
    414450  if(DartWaveOut::find(dwave) == TRUE)
    415451  {
    416     return MMSYSERR_NOTSUPPORTED;
    417   }
    418   else
    419     return(MMSYSERR_INVALHANDLE);
    420 }
    421 
     452        return MMSYSERR_NOTSUPPORTED;
     453  }
     454  else  return(MMSYSERR_INVALHANDLE);
     455}
     456/******************************************************************************/
     457/******************************************************************************/
    422458ODINFUNCTION2(MMRESULT, waveOutSetPlaybackRate,
    423459              HWAVEOUT, hwo,
    … …  
    427463  if(DartWaveOut::find(dwave) == TRUE)
    428464  {
    429     return MMSYSERR_NOTSUPPORTED;
    430   }
    431   else
    432     return(MMSYSERR_INVALHANDLE);
    433 }
    434 
     465        return MMSYSERR_NOTSUPPORTED;
     466  }
     467  else  return(MMSYSERR_INVALHANDLE);
     468}
     469/******************************************************************************/
     470/******************************************************************************/
    435471ODINFUNCTION4(MMRESULT, waveOutMessage,
    436472              HWAVEOUT, hwo,
    … …  
    447483    return(MMSYSERR_INVALHANDLE);
    448484}
    449 
    450 
     485/******************************************************************************/
     486/******************************************************************************/
     487
     488
Note: See TracChangeset for help on using the changeset viewer.