Changeset 8568 for trunk/src


Ignore:
Timestamp:
Jun 4, 2002, 7:36:56 PM (23 years ago)
Author:
sandervl
Message:

Updates for wave playback

Location:
trunk/src/winmm
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/initwinmm.cpp

    r8510 r8568  
    1 /* $Id: initwinmm.cpp,v 1.8 2002-05-28 17:10:02 sandervl Exp $
     1/* $Id: initwinmm.cpp,v 1.9 2002-06-04 17:36:55 sandervl Exp $
    22 *
    33 * WINMM DLL entry point
    … …  
    243243        return MCIERR_CANNOT_LOAD_DRIVER;
    244244    }
    245     USHORT sel = GetFS();
     245    USHORT sel = RestoreOS2FS();
    246246    DWORD ret = pfnmciSendCommand(wDeviceID, wMessage, dwParam1, dwParam2, wUserParm);
    247247    SetFS(sel);
    … …  
    258258        return MCIERR_CANNOT_LOAD_DRIVER;
    259259    }
    260     USHORT sel = GetFS();
     260    USHORT sel = RestoreOS2FS();
    261261    DWORD ret = pfnmciGetErrorString(dwError, lpstrBuffer, wLength);
    262262    SetFS(sel);

  • trunk/src/winmm/waveout.cpp

    r8508 r8568  
    1 /* $Id: waveout.cpp,v 1.24 2002-05-28 14:09:25 sandervl Exp $ */
     1/* $Id: waveout.cpp,v 1.25 2002-06-04 17:36:55 sandervl Exp $ */
    22//#undef DEBUG
    33/*
    … …  
    153153
    154154    if(WaveOut::find(dwave) == TRUE)
    155          return(dwave->restart());
     155         return(dwave->resume());
    156156    else return(MMSYSERR_INVALHANDLE);
    157157}

  • trunk/src/winmm/waveoutbase.h

    r5873 r8568  
    1 /* $Id: waveoutbase.h,v 1.2 2001-06-02 08:30:35 sandervl Exp $ */
     1/* $Id: waveoutbase.h,v 1.3 2002-06-04 17:36:55 sandervl Exp $ */
    22
    33/*
    … …  
    2727     virtual  MMRESULT pause() = 0;
    2828     virtual  MMRESULT stop() = 0;
    29      virtual  MMRESULT restart() = 0;
     29     virtual  MMRESULT resume() = 0;
    3030     virtual  MMRESULT reset() = 0;
    3131     virtual  ULONG    getPosition() = 0;

  • trunk/src/winmm/waveoutdart.cpp

    r8202 r8568  
    1 /* $Id: waveoutdart.cpp,v 1.7 2002-04-07 14:36:31 sandervl Exp $ */
     1/* $Id: waveoutdart.cpp,v 1.8 2002-06-04 17:36:55 sandervl Exp $ */
    22
    33/*
    … …  
    197197        int minbufsize = consumerate/32;
    198198
    199         ulBufSize = pwh->dwBufferLength/2;
    200         if(ulBufSize > minbufsize) {
    201             dprintf(("set buffer size to %d bytes (org size = %d)", minbufsize, pwh->dwBufferLength));
    202             ulBufSize = minbufsize;
     199        if(pwh->dwBufferLength > minbufsize) {
     200            ulBufSize = pwh->dwBufferLength/2;
     201            if(ulBufSize < minbufsize) {
     202                dprintf(("set buffer size to %d bytes (org size = %d)", minbufsize, pwh->dwBufferLength));
     203                ulBufSize = minbufsize;
     204            }
     205        }
     206        else {
     207            //assume application knows what it's doing and use the first buffersize
     208            ulBufSize = pwh->dwBufferLength;
    203209        }
    204210#else
    … …  
    261267        //write buffers to DART; starts playback
    262268        // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
    263         USHORT selTIB = GetFS(); // save current FS selector
     269        USHORT selTIB = RestoreOS2FS(); // save current FS selector
    264270
    265271        MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle,
    … …  
    267273                                 PREFILLBUF_DART);
    268274        SetFS(selTIB);           // switch back to the saved FS selector
    269 
    270275        dprintf(("Dart playing\n"));
    271276    }
    … …  
    290295
    291296        writeBuffer();  //must be called before (re)starting playback
     297
     298        State     = STATE_PLAYING;
     299        fUnderrun = FALSE;
    292300        wmutex.leave();
    293301
    294         if(State == STATE_STOPPED) {//continue playback
    295             restart();
    296         }
    297         else
    298         if(fUnderrun) {
    299             dprintf(("Resume playback after underrun"));
    300             fUnderrun = FALSE;
    301             State = STATE_PLAYING;
    302 
    303             memset(&GenericParms, 0, sizeof(GenericParms));
    304 
    305             // Resume the playback.
    306             mymciSendCommand(DeviceId, MCI_RESUME, MCI_WAIT, (PVOID)&GenericParms, 0);
    307 
    308             //write buffers to DART; starts playback
    309             // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
    310             USHORT selTIB = GetFS(); // save current FS selector
    311 
    312             MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curPlayBuf], 1);
    313 
    314             SetFS(selTIB);           // switch back to the saved FS selector
    315         }
     302        //write buffers to DART; starts playback
     303        // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
     304        USHORT selTIB = RestoreOS2FS(); // save current FS selector
     305
     306        MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle,
     307                                 MixBuffer,
     308                                 PREFILLBUF_DART);
     309        SetFS(selTIB);           // switch back to the saved FS selector
     310
     311        dprintf(("Dart playing\n"));
    316312    }
    317313    return(MMSYSERR_NOERROR);
    … …  
    321317MMRESULT DartWaveOut::pause()
    322318{
    323  MCI_GENERIC_PARMS Params;
     319    MCI_GENERIC_PARMS Params;
    324320
    325321    dprintf(("WINMM: DartWaveOut::pause"));
    … …  
    339335    // Pause the playback.
    340336    mymciSendCommand(DeviceId, MCI_PAUSE, MCI_WAIT, (PVOID)&Params, 0);
     337
     338    return(MMSYSERR_NOERROR);
     339}
     340/******************************************************************************/
     341/******************************************************************************/
     342MMRESULT DartWaveOut::resume()
     343{
     344    MCI_GENERIC_PARMS Params;
     345
     346    dprintf(("DartWaveOut::resume"));
     347   
     348    wmutex.enter();
     349    if(State != STATE_PAUSED) {
     350        wmutex.leave();
     351        return(MMSYSERR_NOERROR);
     352    }
     353
     354    State = STATE_PLAYING;
     355    wmutex.leave();
     356
     357    memset(&Params, 0, sizeof(Params));
     358
     359    // Resume the playback.
     360    mymciSendCommand(DeviceId, MCI_RESUME, MCI_WAIT, (PVOID)&Params, 0);
    341361
    342362    return(MMSYSERR_NOERROR);
    … …  
    408428/******************************************************************************/
    409429/******************************************************************************/
    410 MMRESULT DartWaveOut::restart()
    411 {
    412   int i, curbuf;
    413 
    414     dprintf(("DartWaveOut::restart"));
    415     if(State == STATE_PLAYING)
    416         return(MMSYSERR_NOERROR);
    417 
    418     //Only write buffers to dart if mixer has been initialized; if not, then
    419     //the first buffer write will do this for us.
    420     if(fMixerSetup == TRUE)
    421     {
    422         wmutex.enter();
    423         State     = STATE_PLAYING;
    424         fUnderrun = FALSE;
    425         wmutex.leave();
    426         curbuf = curPlayBuf;
    427 
    428         // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
    429         USHORT selTIB = GetFS(); // save current FS selector
    430 
    431         for(i=0;i<PREFILLBUF_DART;i++)
    432         {
    433             dprintf(("restart: write buffer at %x size %d", MixBuffer[curbuf].pBuffer, MixBuffer[curbuf].ulBufferLength));
    434             MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curbuf], 1);
    435             if(++curbuf == PREFILLBUF_DART)
    436                 curbuf = 0;
    437         }
    438         SetFS(selTIB);           // switch back to the saved FS selector
    439     }
    440 
    441     return(MMSYSERR_NOERROR);
    442 }
    443 /******************************************************************************/
    444 /******************************************************************************/
    445430ULONG DartWaveOut::getPosition()
    446431{
    … …  
    612597    //Transfer buffer to DART
    613598    // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
    614     USHORT selTIB = GetFS(); // save current FS selector
     599    USHORT selTIB = RestoreOS2FS(); // save current FS selector
    615600    MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curPlayBuf], 1);
    616601    SetFS(selTIB);           // switch back to the saved FS selector
    … …  
    678663                             ULONG ulFlags)
    679664{
    680  PTIB2 ptib2;
    681  DartWaveOut *dwave;
     665    PTIB2 ptib2;
     666    DartWaveOut *dwave;
     667
     668    dprintf2(("WaveOutHandler %x %x %x", ulStatus, pBuffer, ulFlags));
    682669
    683670    ptib2 = (PTIB2)_getTIBvalue(offsetof(TIB, tib_ptib2));

  • trunk/src/winmm/waveoutdart.h

    r5421 r8568  
    1 /* $Id: waveoutdart.h,v 1.2 2001-04-01 12:31:01 sandervl Exp $ */
     1/* $Id: waveoutdart.h,v 1.3 2002-06-04 17:36:56 sandervl Exp $ */
    22
    33/*
    … …  
    3838     virtual  MMRESULT pause();
    3939     virtual  MMRESULT stop();
    40      virtual  MMRESULT restart();
     40     virtual  MMRESULT resume();
    4141     virtual  MMRESULT setVolume(ULONG ulVol);
    4242     virtual  MMRESULT reset();

  • trunk/src/winmm/waveoutdaud.cpp

    r8202 r8568  
    1 /* $Id: waveoutdaud.cpp,v 1.7 2002-04-07 14:36:32 sandervl Exp $ */
     1/* $Id: waveoutdaud.cpp,v 1.8 2002-06-04 17:36:56 sandervl Exp $ */
    22
    33/*
    … …  
    160160    }
    161161
    162     if(State == STATE_STOPPED) {//continue playback
    163         restart();
    164     }
    165     else
    166     if(fUnderrun) {
    167         dprintf(("Resume playback after underrun"));
     162    if(State == STATE_STOPPED || fUnderrun) {
     163        wmutex.enter();
     164        State     = STATE_PLAYING;
    168165        fUnderrun = FALSE;
    169         State = STATE_PLAYING;
    170 
    171         // Resume the playback.
    172         resume();
     166        wmutex.leave();
     167
     168        if(sendIOCTL(DAUDIO_START, &cmd)) {
     169            dprintf(("Unable to (re)start stream!!!!!"));
     170            return MMSYSERR_ERROR;
     171        }
    173172    }
    174173    return(MMSYSERR_NOERROR);
    … …  
    266265/******************************************************************************/
    267266/******************************************************************************/
    268 MMRESULT DAudioWaveOut::restart()
    269 {
    270     DAUDIO_CMD cmd;
    271 
    272     dprintf(("DAudioWaveOut::restart"));
    273     if(State == STATE_PLAYING)
    274         return(MMSYSERR_NOERROR);
    275 
    276     wmutex.enter();
    277     State     = STATE_PLAYING;
    278     fUnderrun = FALSE;
    279     wmutex.leave();
    280 
    281     return sendIOCTL(DAUDIO_START, &cmd);
    282 }
    283 /******************************************************************************/
    284 /******************************************************************************/
    285267ULONG DAudioWaveOut::getPosition()
    286268{

  • trunk/src/winmm/waveoutdaud.h

    r5643 r8568  
    1 /* $Id: waveoutdaud.h,v 1.4 2001-04-30 21:06:56 sandervl Exp $ */
     1/* $Id: waveoutdaud.h,v 1.5 2002-06-04 17:36:56 sandervl Exp $ */
    22
    33/*
    … …  
    3030     virtual  MMRESULT pause();
    3131     virtual  MMRESULT stop();
    32      virtual  MMRESULT restart();
     32     virtual  MMRESULT resume();
    3333     virtual  MMRESULT setVolume(ULONG ulVol);
    3434     virtual  MMRESULT reset();
    … …  
    4444
    4545private:
    46        MMRESULT resume();
    4746       BOOL     handler();
    4847       MMRESULT sendIOCTL(ULONG cmd, DAUDIO_CMD *pDataPacket);
Note: See TracChangeset for help on using the changeset viewer.