windows-xp/Source/XPSP1/NT/multimedia/media/sndrec32/soundrec/wave.c

/* (C) Copyright Microsoft Corporation 1991-1994.  All Rights Reserved */
/* wave.c
 *
 * Waveform input and output.
 */

/** Revision History.
 *  4/2/91    LaurieGr (AKA LKG) Ported to WIN32 / WIN16 common code
 *  17/Feb/94 LaurieGr Merged Daytona and Motown versions.

 *  READ ME

 *  The new soundrec was changed to use multiple headers for the following
 *  reason.  The Win3.1 version of soundrec did one waveOutWrite (with one
 *  WAVEHDR) for the entire buffer, this worked okay for relatively small
 *  files, but the moment we started using large files (>
 *  3meg) it was becoming cumbersome since it needed all of that
 *  data page-locked.  It occasionally paged for > 1 min.
 *  Note: The o-scope display for soundrec is also updated on
 *  the WOM_DONE message, it no longer looks at the buffer given on the
 *  waveOutWrite before the WOM_DONE message for the buffer
 *  is received.  This is why input mapping was not implemented
 *  in ACM on product one, there were drawing artifacts in the
 *  o-scope window.

 *  The pausing algorithm was changed for the following reason.
 *  If you launch two instances of soundrec (with two wave devices)
 *  and do the following...  Play a .wav file on instance #1
 *  (allocates first device); play a .wav file on instance #2
 *  (allocates second device); press stop on instance #1
 *  (frees first device); press rewind on instance #2
 *  (frees second device, allocates first device).
 *  Essentially, you press rewind in soundrec and you
 *  switch devices.  Since there is no explicit stop,
 *  the device should not be closed.
 */

#include "nocrap.h"
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <mmreg.h>

#ifdef USE_MMCNTRLS
#define NOTOOLBAR
#define NOMENUHELP
#define NODRAGLIST
#define NOBITMAPBTN
#define NOMENUHELP
#define NODRAGLIST
#include "mmcntrls.h"
#else
#include <commctrl.h>
#include "buttons.h"
#endif

#define INCLUDE_OLESTUBS
#include "SoundRec.h"
#include "srecnew.h"
#include "reg.h"

#ifndef LPHWAVE
typedef HWAVE FAR *LPHWAVE;
#endif

/* globals that maintain the state of the current waveform */
BOOL            gfSyncDriver;           // true if open device is sync
PWAVEFORMATEX   gpWaveFormat;           // format of WAVE file
DWORD           gcbWaveFormat;          // size of WAVEFORMAT
LPTSTR          gpszInfo = NULL;        // file info
HPBYTE          gpWaveSamples = NULL;   // pointer to waveoform samples
LONG            glWaveSamples = 0;  // number of samples total in buffer
LONG            glWaveSamplesValid = 0; // number of samples that are valid
LONG            glWavePosition = 0; // current wave position in samples from start
LONG            glStartPlayRecPos;  // position when play or record started
LONG            glSnapBackTo = 0;
HWAVEOUT        ghWaveOut = NULL;   // wave-out device (if playing)
HWAVEIN         ghWaveIn = NULL;    // wave-out device (if recording)
BOOL            gfStoppingHard = FALSE; // StopWave() was called?
                                        // true during the call to FinishPlay()
static BOOL     fStopping = FALSE;  // StopWave() was called?
DWORD           grgbStatusColor;    // color of status text

DWORD           gdwCurrentBufferPos;    // Current playback/record pos (bytes)
DWORD           gdwBytesPerBuffer;      // Bytes in each buffer we give drvr
DWORD           gdwTotalLengthBytes;    // Length of entire buffer in bytes
DWORD           gdwBufferDeltaMSecs;    // # msecs added to end on record
BOOL            gfTimerStarted;

WAVEHDR    FAR *gapWaveHdr[MAX_WAVEHDRS];
UINT            guWaveHdrs;             // 1/2 second of buffering?
UINT            guWaveHdrsInUse;        // # we actually could write
UINT            gwMSecsPerBuffer;       // 1/8 second

#ifdef THRESHOLD
int iNoiseLevel = 15;      // 15% of full volume is defined to be quiet
int iQuietLength = 1000;  // 1000 samples in a row quiet means quiet
#endif // THRESHOLD

BOOL        fFineControl = FALSE; // fine scroll control (SHIFT key down)

/*------------------------------------------------------------------
|  fFineControl:
|  This turns on place-saving to help find your way
|  a wave file.  It's controlled by the SHIFT key being down.
|  If the key is down when you scroll (see soundrec.c) then it scrolls
|  fine amounts - 1 sample or 10 samples rather than about 100 or 1000.
|  In addition, if the SHIFT key is down when a sound is started
|  playing or recording, the position will be remembered and it will
|  snap back to that position.  fFineControl says whether we are
|  remembering such a position to snap back to.  SnapBack does the
|  position reset and then turns the flag off.  There is no such flag
|  or mode for scrolling, the SHIFT key state is examined on every
|  scroll command (again - see Soundrec.c)
 --------------------------------------------------------------------*/



/* dbgShowMemUse: display memory usage figures on debugger */
void dbgShowMemUse()
{
    MEMORYSTATUS ms;

    GlobalMemoryStatus(&ms);
//    dprintf( "load %d\n    PHYS tot %d avail %d\n    PAGE tot %d avail %d\n    VIRT tot %d avail %d\n"
//           , ms.dwMemoryLoad
//           , ms.dwTotalPhys, ms.dwAvailPhys
//           , ms.dwTotalPageFile, ms.dwAvailPageFile
//           , ms.dwTotalVirtual, ms.dwAvailVirtual
//           );

} // dbgShowMemUse

/* PLAYBACK and PAGING on NT
|
|  In order to try to get decent performance at the highest data rates we
|  need to try very hard to get all the data into storage.  The paging rate
|  on several x86 systems is only just about or even a little less than the
|  maximum data rate.  We therefore do the following:
|  a. Pre-touch the first 1MB of data when we are asked to start playing.
|     If it is already in storage, this is almost instantaneous.
|     If it needs to be faulted in, there will be a delay, but it will be well
|     worth having this delay at the start rather than clicks and pops later.
|     (At 44KHz 16 bit stereo it could be about 7 secs, 11KHz 8 bit mono it
|     would only be about 1/2 sec anyway).
|  b. Kick off a separate thread to run through the data touching 1 byte per
|     page.  This thread is Created when we start playing, periscopes the global
|     static flag fStopping and exits when it reaches the end of the buffer or when
|     that flag is set.  The global thread handle is kept in ghPreTouch and this is
|     initially invalid.  We WAIT on this handle (if valid) to clear the thread out
|     before creating a new one (so there will be at most one).  We do NOT do any
|     of this for record.  The paging does not have to happen in real time for
|     record.  It can get quite a way behind and still manage.
|
|  This whole thing is really a bit of a hack and sits uncomfortably on NT.
|  The memory management works by paging out the least recently used (LRU)
|  pages.  By stepping right though a 10Meg buffer, we will cause a lot of
|  code to get paged out.  It would be better to have a file and read it
|  in section by section into a much smaller buffer (like MPlayer does).

   Note that the use of multiple headers doesn't really affect anything.
   The headers merely point at different sections of the wave buffer.
   It merely makes the addressing of the starting point slightly different.
*/
HANDLE ghPreTouch = NULL;

typedef struct {
        LPBYTE Addr;  // start of buffer to pre-touch
        DWORD  Len;   // length of buffer to pre-touch
} PRETOUCHTHREADPARM;

/* PreToucher
**
** Asynchronous pre-toucher thread.  The thread parameter dw
** is realy a poionter to a PRETOUCHTHREADPARAM
*/
DWORD PreToucher(DWORD_PTR dw)
{
    PRETOUCHTHREADPARM * pttp;

    long iSize;
    BYTE * pb;

    pttp = (PRETOUCHTHREADPARM *) dw;
    if (!pttp) return 0;

    iSize = pttp->Len;
    pb = pttp->Addr;

    GlobalFreePtr(pttp);
    if (!pb) return 0;

    while (iSize>0 && !fStopping) {
        volatile BYTE b;
        b = *pb;
        pb += 4096;    // move to next page.  Are they ALWAYS 4096?
        iSize -= 4096; // and count it off
    }
//  dprintf(("All pretouched!"));
    return 0;
} // PreToucher


/* StartPreTouchThread
**
** Start a thread running which will run through the wave buffer
** pre-touching one byte every page to ensure that the stuff is
** faulted into memory before we actually need it.
** This was needed to make 44KHz 16 bit stereo work on a
** 25MHx 386 with 16MB memory running Windows NT.
*/
void StartPreTouchThread(LPBYTE lpb, LONG cb)
{
    /* before we start the thing running, pretouch the first bit of memory
       to give the paging a head start.  THEN start the thread running.
    */
    {    long bl = cb;
         BYTE * pb = lpb;
         if (bl>1000000) bl = 1000000;   /* 1 Meg, arbitrarily */
         pb += bl;
         while (bl>0){
             volatile BYTE b;
             b = *pb;
             pb-=4096;
             bl -= 4096;
         }
    }


    {
         PRETOUCHTHREADPARM * pttp;
         DWORD dwThread;

         if (ghPreTouch!=NULL) {
             fStopping = TRUE;
             WaitForSingleObject(ghPreTouch, INFINITE);
             CloseHandle(ghPreTouch);
             ghPreTouch = NULL;
         }
         fStopping = FALSE;
         pttp = (PRETOUCHTHREADPARM *)GlobalAllocPtr(GHND, sizeof(PRETOUCHTHREADPARM));
                /* freed by the invoked thread */

         if (pttp!=NULL) {
             pttp->Addr = lpb;
             pttp->Len = cb;
             ghPreTouch = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PreToucher, pttp, 0, &dwThread);
             // If the CreateThread fails there will be a memory leak.  It's very small,
             // unlikely and not frequent.  Not worth fixing.
         }
    }
} // StartPreTouchThread



/* wfBytesToSamples(pwf, lBytes)
 *
 * convert a byte offset into a sample offset.
 *
 * lSamples = (lBytes/nAveBytesPerSec) * nSamplesPerSec
 *
 */
LONG PASCAL wfBytesToSamples(WAVEFORMATEX* pwf, LONG lBytes)
{
    return MulDiv(lBytes,pwf->nSamplesPerSec,pwf->nAvgBytesPerSec);
}

/* wfSamplesToBytes(pwf, lSample)
 *
 * convert a sample offset into a byte offset, with correct alignment
 * to nBlockAlign.
 *
 * lBytes = (lSamples/nSamplesPerSec) * nBytesPerSec
 *
 */
LONG PASCAL wfSamplesToBytes(WAVEFORMATEX* pwf, LONG lSamples)
{
    LONG lBytes;

    lBytes = MulDiv(lSamples,pwf->nAvgBytesPerSec,pwf->nSamplesPerSec);

    // now align the byte offset to nBlockAlign
#ifdef ROUND_UP
    lBytes = ((lBytes + pwf->nBlockAlign-1) / pwf->nBlockAlign) * pwf->nBlockAlign;
#else
    lBytes = (lBytes / pwf->nBlockAlign) * pwf->nBlockAlign;
#endif

    return lBytes;
}

/* wfSamplesToTime(pwf, lSample)
 *
 * convert a sample offset into a time offset in miliseconds.
 *
 * lTime = (lSamples/nSamplesPerSec) * 1000
 *
 */
LONG PASCAL wfSamplesToTime(WAVEFORMATEX* pwf, LONG lSamples)
{
    return MulDiv(lSamples,1000,pwf->nSamplesPerSec);
}

/* wfTimeToSamples(pwf, lTime)
 *
 * convert a time index into a sample offset.
 *
 * lSamples = (lTime/1000) * nSamplesPerSec
 *
 */
LONG PASCAL wfTimeToSamples(
    WAVEFORMATEX*   pwf,
    LONG            lTime)
{
    return MulDiv(lTime,pwf->nSamplesPerSec,1000);
}

/*
 * function to determine if a WAVEFORMAT is a valid PCM format we support for
 * editing and such.
 *
 * we only handle the following formats...
 *
 *  Mono 8bit
 *  Mono 16bit
 *  Stereo 8bit
 *  Stereo 16bit
 * */
BOOL PASCAL IsWaveFormatPCM(WAVEFORMATEX* pwf)
{
    if (!pwf)
        return FALSE;

    if (pwf->wFormatTag != WAVE_FORMAT_PCM)
        return FALSE;

    if (pwf->nChannels < 1 || pwf->nChannels > 2)
        return FALSE;

    if ((pwf->wBitsPerSample != 8) && (pwf->wBitsPerSample != 16))
        return FALSE;

    return TRUE;
} // IsWaveFormatPCM

void PASCAL WaveFormatToString(LPWAVEFORMATEX lpwf, LPTSTR sz)
{
    TCHAR achFormat[80];

    //
    //  this is what we expect the resource strings to be...
    //
    // IDS_MONOFMT      "Mono %d%c%03dkHz, %d-bit"
    // IDS_STEREOFMT    "Stereo %d%c%03dkHz, %d-bit"
    //
    if (gfLZero || ((WORD)(lpwf->nSamplesPerSec / 1000) != 0)){
    LoadString(ghInst,lpwf->nChannels == 1 ? IDS_MONOFMT:IDS_STEREOFMT,
                   achFormat, SIZEOF(achFormat));

    wsprintf(sz, achFormat,
                 (UINT)  (lpwf->nSamplesPerSec / 1000), chDecimal,
                 (UINT)  (lpwf->nSamplesPerSec % 1000),
                 (UINT)  (lpwf->nAvgBytesPerSec * 8 / lpwf->nSamplesPerSec / lpwf->nChannels));
    } else {
        LoadString(ghInst,lpwf->nChannels == 1 ? IDS_NOZEROMONOFMT:
                   IDS_NOZEROSTEREOFMT, achFormat, SIZEOF(achFormat));

        wsprintf(sz, achFormat,
                 chDecimal,
                 (WORD)  (lpwf->nSamplesPerSec % 1000),
                 (WORD)  (lpwf->nAvgBytesPerSec * 8 / lpwf->nSamplesPerSec / lpwf->nChannels));
    }
} // WaveFormatToString

#ifdef THRESHOLD

/*
 * SkipToStart()
 *
 * move forward through sound file to the start of a noise.
 * What is defined as a noise is rather arbitrary.  See NoiseLevel
 */
void FAR PASCAL SkipToStart(void)
{  BYTE * pb;   // pointer to 8 bit sample
   int  * pi;   // pointer to 16 bit sample
   BOOL f8;     // 8 bit samples
   BOOL fStereo; // 2 channels
   int  iLo;    // minimum quiet value
   int  iHi;    // maximum quiet value

   fStereo = (gpWaveFormat->nChannels != 1);
   f8 = (pWaveFormat->wBitsPerSample == 8);

   if (f8)
   {  int iDelta = MulDiv(128, iNoiseLevel, 100);
      iLo = 128 - iDelta;
      iHi = 128 + iDelta;
   }
   else
   {  int iDelta = MulDiv(32767, iNoiseLevel, 100);
      iLo = 0 - iDelta;
      iHi = 0 + iDelta;
   }

   pb = (BYTE *) gpWaveSamples
                           + wfSamplesToBytes(gpWaveFormat, glWavePosition);
   pi = (int *)pb;

   while (glWavePosition < glWaveSamplesValid)
   {   if (f8)
       {   if ( ((int)(*pb) > iHi) || ((int)(*pb) < iLo) )
              break;
           ++pb;
           if (fStereo)
           {   if ( ((int)(*pb) > iHi) || ((int)(*pb) < iLo) )
               break;
               ++pb;
           }
       }
       else
       {   if ( (*pi > iHi) || (*pi < iLo) )
              break;
           ++pi;
           if (fStereo)
           {  if ( (*pi > iHi) || (*pi < iLo) )
                 break;
              ++pi;
           }
       }
       ++glWavePosition;
   }
   UpdateDisplay(FALSE);
} /* SkipToStart */


/*
 * SkipToEnd()
 *
 * move forward through sound file to a quiet place.
 * What is defined as quiet is rather arbitrary.
 * (Currently less than 20% of full volume for 1000 samples)
 */
void FAR PASCAL SkipToEnd(void)
{  BYTE * pb;   // pointer to 8 bit sample
   int  * pi;   // pointer to 16 bit sample
   BOOL f8;     // 8 bit samples
   BOOL fStereo; // 2 channels
   int  cQuiet;  // number of successive quiet samples so far
   LONG lQuietPos; // Start of quiet period
   LONG lPos;      // Search counter

   int  iLo;    // minimum quiet value
   int  iHi;    // maximum quiet value

   fStereo = (gpWaveFormat->nChannels != 1);
   f8 = (gpWaveFormat->wBitsPerSample == 8);

   if (f8)
   {  int iDelta = MulDiv(128, iNoiseLevel, 100);
      iLo = 128 - iDelta;
      iHi = 128 + iDelta;
   }
   else
   {  int iDelta = MulDiv(32767, iNoiseLevel, 100);
      iLo = 0 - iDelta;
      iHi = 0 + iDelta;
   }

   pb = (BYTE *) gpWaveSamples
                           + wfSamplesToBytes(gpWaveFormat, glWavePosition);
   pi = (int *)pb;

   cQuiet = 0;
   lQuietPos = glWavePosition;
   lPos = glWavePosition;

   while (lPos < glWaveSamplesValid)
   {   BOOL fQuiet = TRUE;
       if (f8)
       {   if ( ((int)(*pb) > iHi) || ((int)(*pb) < iLo) ) fQuiet = FALSE;
           if (fStereo)
           {   ++pb;
               if ( ((int)(*pb) > iHi) || ((int)(*pb) < iLo) ) fQuiet = FALSE;
           }
           ++pb;
       }
       else
       {   if ( (*pi > iHi) || (*pi < iLo) ) fQuiet = FALSE;
           if (fStereo)
           {   ++pi;
               if ( (*pi > iHi) || (*pi < iLo) ) fQuiet = FALSE;
           }
           ++pi;
       }
       if (!fQuiet) cQuiet = 0;
       else if (cQuiet == 0)
       {    lQuietPos = lPos;
            ++cQuiet;
       }
       else
       {  ++cQuiet;
          if (cQuiet>=iQuietLength) break;
       }

       ++lPos;
   }
   glWavePosition = lQuietPos;
   UpdateDisplay(FALSE);
} /* SkipToEnd */


/*
 * IncreaseThresh()
 *
 * Increase the threshold of what counts as quiet by about 25%
 * Ensure it changes by at least 1 unless on the stop already
 *
 */
void FAR PASCAL IncreaseThresh(void)
{   iNoiseLevel = MulDiv(iNoiseLevel+1, 5, 4);
    if (iNoiseLevel>100) iNoiseLevel = 100;
} // IncreaseThreshold


/*
 * DecreaseThresh()
 *
 * Decrease the threshold of what counts as quiet by about 25%
 * Ensure it changes by at least 1 unless on the stop already
 * It's a divisor, so we INcrease the divisor, but never to 0
 *
 */
void FAR PASCAL DecreaseThresh(void)
{   iNoiseLevel = MulDiv(iNoiseLevel, 4, 5)-1;
    if (iNoiseLevel <=0) iNoiseLevel = 0;
} // DecreaseThreshold

#endif //THRESHOLD


/* fOK = AllocWaveBuffer(lSamples, fErrorBox, fExact)
 *
 * If <gpWaveSamples> is NULL, allocate a buffer <lSamples> in size and
 * point <gpWaveSamples> to it.
 *
 * If <gpWaveSamples> already exists, then just reallocate it to be
 * <lSamples> in size.
 *
 * if fExact is FALSE, then when memory is tight, allocate less than
 * the amount asked for - so as to give reasonable performance,
 * if fExact is TRUE then when memory is short, FAIL.
 * NOTE: On NT on a 16MB machine it WILL GIVE you 20MB, i.e. it does
 * NOT FAIL - but may (unacceptably) take SEVERAL MINUTES to do so.
 * So better to monitor the situation ourselves and ask for less.
 *
 * On success, return TRUE.  On failure, return FALSE but if and only
 * if fErrorBox is TRUE then display a MessageBox first.
 */
BOOL FAR PASCAL AllocWaveBuffer(
        LONG    lSamples,       // samples to allocate
        BOOL    fErrorBox,      // TRUE if you want an error displayed
        BOOL    fExact)         // TRUE means allocate the full amount requested or FAIL
{
    LONG_PTR    lAllocSamples;  // may be bigger than lSamples
    LONG_PTR    lBytes;     // bytes to allocate
    LONG_PTR    lBytesReasonable;  // bytes reasonable to use (phys mem avail).

    MEMORYSTATUS ms;

    lAllocSamples = lSamples;

    lBytes = wfSamplesToBytes(gpWaveFormat, lSamples);

    /* Add extra space to compensate for code generation bug which
        causes reference past end */
    /* don't allocate anything to be zero bytes long */
    lBytes += sizeof(DWORD_PTR);

    if (gpWaveSamples == NULL || glWaveSamplesValid == 0L)
    {
        if (gpWaveSamples != NULL)
        {   DPF(TEXT("Freeing %x\n"),gpWaveSamples);
            GlobalFreePtr(gpWaveSamples);
        }
        GlobalMemoryStatus(&ms);
        lBytesReasonable = ms.dwAvailPhys;  // could multiply by a fudge factor
        if (lBytesReasonable<1024*1024)
             lBytesReasonable = 1024*1024;

        if (lBytes>lBytesReasonable)
        {
        if (fExact) goto ERROR_OUTOFMEM; // Laurie's first goto in 10 years.

            // dprintf("Reducing buffer from %d to %d\n", lBytes, lBytesReasonable);
            lAllocSamples = wfBytesToSamples(gpWaveFormat,(long)lBytesReasonable);
            lBytes = lBytesReasonable+sizeof(DWORD_PTR);
        }

        /* allocate <lBytes> of memory */

        gpWaveSamples = GlobalAllocPtr(GHND|GMEM_SHARE, lBytes);

        if (gpWaveSamples == NULL)
        {
            DPF(TEXT("wave.c Alloc failed, point A.  Wanted %d\n"), lBytes);
            glWaveSamples = glWaveSamplesValid = 0L;
            glWavePosition = 0L;
            goto ERROR_OUTOFMEM;
        }
        else {
            DPF(TEXT("wave.c Allocated  %d bytes at %x\n"), lBytes, (DWORD_PTR)gpWaveSamples );
        }

        glWaveSamples = (long)lAllocSamples;
    }
    else
    {
        HPBYTE  pch;

        GlobalMemoryStatus(&ms);
        lBytesReasonable = ms.dwAvailPhys;
        
        if (lBytesReasonable<1024*1024) lBytesReasonable = 1024*1024;

        if (lBytes > lBytesReasonable+wfSamplesToBytes(gpWaveFormat,glWaveSamplesValid))
        {
        if (fExact) goto ERROR_OUTOFMEM; // Laurie's second goto in 10 years.

            lBytesReasonable += wfSamplesToBytes(gpWaveFormat,glWaveSamplesValid);
            lAllocSamples = wfBytesToSamples(gpWaveFormat,(long)lBytesReasonable);
            lBytes = lBytesReasonable+4;
        }

        DPF(TEXT("wave.c ReAllocating  %d bytes at %x\n"), lBytes, (DWORD_PTR)gpWaveSamples );

        pch = GlobalReAllocPtr(gpWaveSamples, lBytes, GHND|GMEM_SHARE);

        if (pch == NULL)
        {
            DPF(TEXT("wave.c Realloc failed.  Wanted %d\n"), lBytes);
            goto ERROR_OUTOFMEM;
        }
        else{ DPF(TEXT("wave.c Reallocated %d at %x\n"), lBytes,(DWORD_PTR)pch);
        }
        
        gpWaveSamples = pch;
        glWaveSamples = (long)lAllocSamples;
    }

    /* make sure <glWaveSamplesValid> and <glWavePosition> don't point
     * to places they shouldn't
     */
    if (glWaveSamplesValid > glWaveSamples)
        glWaveSamplesValid = glWaveSamples;
    if (glWavePosition > glWaveSamplesValid)
        glWavePosition = glWaveSamplesValid;

    dbgShowMemUse();

    return TRUE;

ERROR_OUTOFMEM:
    if (fErrorBox) {
        ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
            IDS_APPTITLE, IDS_OUTOFMEM);
    }
    dbgShowMemUse();
    return FALSE;
} // AllocWaveBuffer


/* CreateDefaultWaveFormat(lpWaveFormat)
 *
 * Fill in <*lpWaveFormat> with the "best" format that can be used
 * for recording.  If recording does not seem to be available, return
 * FALSE and set to a default "least common denominator"
 * wave audio format.
 *
 */
WORD wFormats[] =
    {
        FMT_16BIT | FMT_22k | FMT_MONO,  /* Best: 16-bit 22KHz */
        FMT_16BIT | FMT_11k | FMT_MONO,  /* Best: 16-bit 11KHz */
        FMT_8BIT  | FMT_22k | FMT_MONO,  /* Next: 8-bit 22KHz  */
        FMT_8BIT  | FMT_11k | FMT_MONO   /* Last: 8-bit 11KHz  */
    };
#define NUM_FORMATS (sizeof(wFormats)/sizeof(wFormats[0]))

/*
 * This relies on the behaviour of WAVE_MAPPER to supply a correct
 * header.
 *
 *---------------------------------------------------------------
 * 6/16/93          TimHa
 * Change back to getting a 'best' default format from the
 * above array of formats.  This is only used if ACM 2.0 isn't
 * available to do a format for us.
 *---------------------------------------------------------------
 *
 * */
BOOL PASCAL
CreateDefaultWaveFormat(LPWAVEFORMATEX lpwf, UINT uDeviceID)
{
    int i;

    lpwf->wFormatTag = WAVE_FORMAT_PCM;

    for (i = 0; i < NUM_FORMATS; i++) {
        if (CreateWaveFormat(lpwf, wFormats[i], (UINT)WAVE_MAPPER)){
            return TRUE;
        }

    }
    //
    // Couldn't find anything: leave worst format and return.
    //
    return FALSE;
} /* CreateDefaultWaveFormat */

/* BOOL PASCAL CreateWaveFormat(LPWAVEFORMATEX lpwf, WORD fmt, UINT uDeviceID)
 *
 * */
BOOL PASCAL
CreateWaveFormat(LPWAVEFORMATEX lpwf, WORD fmt, UINT uDeviceID)
{
    if (fmt == FMT_DEFAULT)
        return CreateDefaultWaveFormat(lpwf, uDeviceID);

    lpwf->wFormatTag      = WAVE_FORMAT_PCM;
    lpwf->nSamplesPerSec  = (fmt & FMT_RATE) * 11025;
    lpwf->nChannels       = (WORD)(fmt & FMT_STEREO) ? 2 : 1;
    lpwf->wBitsPerSample  = (WORD)(fmt & FMT_16BIT) ? 16 : 8;
    lpwf->nBlockAlign     = (WORD)lpwf->nChannels * ((lpwf->wBitsPerSample + 7) / 8);
    lpwf->nAvgBytesPerSec = lpwf->nSamplesPerSec * lpwf->nBlockAlign;

    return waveInOpen(NULL
                      , uDeviceID
                      , (LPWAVEFORMATEX)lpwf
                      , 0L
                      , 0L
                      , WAVE_FORMAT_QUERY|WAVE_ALLOWSYNC) == 0;
    
} /* CreateWaveFormat */


/*
 * */
BOOL NEAR PASCAL FreeWaveHeaders(void)
{
    UINT    i;

    DPF(TEXT("FreeWaveHeaders!\n"));

    // #pragma message("----FreeWaveHeaders: should probably call on exit!")

    //
    //  free any previously allocated wave headers..
    //
    for (i = 0; i < MAX_WAVEHDRS; i++)
    {
        if (gapWaveHdr[i])
        {
            GlobalFreePtr(gapWaveHdr[i]);
            gapWaveHdr[i] = NULL;
        }
    }

    return (TRUE);
} /* FreeWaveHeaders() */


/*
 * */
BOOL NEAR PASCAL
AllocWaveHeaders(
    WAVEFORMATEX *  pwfx,
    UINT            uWaveHdrs)
{
    UINT        i;
    LPWAVEHDR   pwh;

    FreeWaveHeaders();

    //
    //  allocate all of the wave headers/buffers for streaming
    //
    for (i = 0; i < uWaveHdrs; i++)
    {
        pwh = GlobalAllocPtr(GMEM_MOVEABLE, sizeof(WAVEHDR));
        
        if (pwh == NULL)
            goto AWH_ERROR_NOMEM;

        pwh->lpData         = NULL;
        pwh->dwBufferLength = 0L;
        pwh->dwFlags        = 0L;
        pwh->dwLoops        = 0L;

        gapWaveHdr[i] = pwh;
    }

    return (TRUE);

AWH_ERROR_NOMEM:
    FreeWaveHeaders();
    return (FALSE);
} /* AllocWaveHeaders() */


/* WriteWaveHeader

   Writes wave header - also actually starts the wave I/O
   by WaveOutWrite or WaveInAddBuffer.
*/
UINT NEAR PASCAL WriteWaveHeader(LPWAVEHDR pwh,BOOL fJustUnprepare)
{
    UINT        uErr;
    BOOL        fInput;
    DWORD       dwLengthToWrite;
#if 1
    //see next "mmsystem workaround"
    BOOL        fFudge;
#endif
    fInput = (ghWaveIn != NULL);

    if (pwh->dwFlags & WHDR_PREPARED)
    {
        if (fInput)
            uErr = waveInUnprepareHeader(ghWaveIn, pwh, sizeof(WAVEHDR));
        else
            uErr = waveOutUnprepareHeader(ghWaveOut, pwh, sizeof(WAVEHDR));

        //
        //  because Creative Labs thinks they know what they are doing when
        //  they don't, we cannot rely on the unprepare succeeding like it
        //  should after they have posted the header back to us... they fail
        //  the waveInUnprepareHeader with WAVERR_STILLPLAYING (21h) even
        //  though the header has been posted back with the WHDR_DONE bit
        //  set!!
        //
        //  absolutely smurphingly brilliant! and i thought Media Vision was
        //  the leader in this type of 'Creativity'!! they have competition!
        //
#if 0
        if (uErr)
        {
            if (fInput && (uErr == WAVERR_STILLPLAYING) && (pwh->dwFlags & WHDR_DONE))
            {
                DPF(TEXT("----PERFORMING STUPID HACK FOR CREATIVE LABS' SBPRO----\n"));
                pwh->dwFlags &= ~WHDR_PREPARED;
            }
            else
            {
                DPF(TEXT("----waveXXUnprepareHeader FAILED! [%.04Xh]\n"), uErr);
                return (uErr);
            }
        }
#else
        if (uErr)
        {
            DPF(TEXT("----waveXXUnprepareHeader FAILED! [%.04Xh]\n"), uErr);
            return (uErr);
        }
#endif
    }

    if (fJustUnprepare)
        return (0);

    dwLengthToWrite = gdwTotalLengthBytes - gdwCurrentBufferPos;

    if (gdwBytesPerBuffer < dwLengthToWrite)
        dwLengthToWrite = gdwBytesPerBuffer;

    //
    //  if there is nothing to write (either no more data for output or no
    //  more room for input), then return -1 which signifies this case...
    //
    if (dwLengthToWrite == 0L)
    {
        DPF(TEXT("WriteWaveHeader: no more data!\n"));
        return (UINT)-1;
    }

#if 1
//"mmsystem workaround"  Apparently waveXXXPrepareHeader can't pagelock 1 byte, so make us 2
    fFudge = (dwLengthToWrite==1);
    pwh->dwBufferLength = dwLengthToWrite + ((fFudge)?1L:0L);
#else
    pwh->dwBufferLength = dwLengthToWrite;
#endif

    pwh->lpData         = (LPSTR)&gpWaveSamples[gdwCurrentBufferPos];
    pwh->dwBytesRecorded= 0L;
    pwh->dwFlags        = 0L;
    pwh->dwLoops        = 0L;
    pwh->lpNext         = NULL;
    pwh->reserved       = 0L;

    if (fInput)
        uErr = waveInPrepareHeader(ghWaveIn, pwh, sizeof(WAVEHDR));
    else
        uErr = waveOutPrepareHeader(ghWaveOut, pwh, sizeof(WAVEHDR));

    if (uErr)
    {
        DPF(TEXT("waveXXPrepareHeader FAILED! [%.04Xh]\n"), uErr);
        return uErr;
    }

#if 1
//"mmsystem workaround". Unfudge
    if (fFudge)
        pwh->dwBufferLength -= 1;
#endif

    if (fInput)
        uErr = waveInAddBuffer(ghWaveIn, pwh, sizeof(WAVEHDR));
    else
        uErr = waveOutWrite(ghWaveOut, pwh, sizeof(WAVEHDR));

    if (uErr)
    {
        DPF(TEXT("waveXXAddBuffer FAILED! [%.04Xh]\n"), uErr);

        if (fInput)
            waveInUnprepareHeader(ghWaveIn, pwh, sizeof(WAVEHDR));
        else
            waveOutUnprepareHeader(ghWaveOut, pwh, sizeof(WAVEHDR));

        return uErr;
    }

    gdwCurrentBufferPos += dwLengthToWrite;

    return 0;
} /* WriteWaveHeader() */


/* if fFineControl is set then reset the position and clear the flag */
void FAR PASCAL SnapBack(void)
{
    if (fFineControl)
    {
        glWavePosition = glSnapBackTo;
        UpdateDisplay(TRUE);
        fFineControl = FALSE;
    }
} /* SnapBack */


/* fOK = NewWave()
 *
 * Destroy the current waveform, and create a new empty one.
 *
 * On success, return TRUE.  On failure, display an error message
 * and return FALSE.
 */
BOOL FAR PASCAL
NewWave(WORD fmt, BOOL fNewDlg)
{
    BOOL    fOK = TRUE;
    
    DPF(TEXT("NewWave called: %s\n"),(gfEmbeddedObject?TEXT("Embedded"):TEXT("App")));
#ifndef CHICAGO
    //
    // bring up the dialog to get a new waveformat IFF this was
    // selected from the File menu
    //
    if (fNewDlg)
    {
        PWAVEFORMATEX pWaveFormat;
        UINT cbWaveFormat;

        if (NewSndDialog(ghInst, ghwndApp, gpWaveFormat, gcbWaveFormat, &pWaveFormat, &cbWaveFormat))
        {
            /* User made a selection */
            /* destroy the current document */
            DestroyWave();
            gpWaveFormat = pWaveFormat;
            gcbWaveFormat = cbWaveFormat;
            gidDefaultButton = ID_RECORDBTN;
        }
        else
        {
            /* user cancelled or out of mem */
            /* should probably handle outofmem differently */
            goto RETURN_ERROR;
        }
    }
    else
#endif        
    {

        DWORD           cbwfx;
        LPWAVEFORMATEX  pwfx;


        if (!SoundRec_GetDefaultFormat(&pwfx, &cbwfx))
        {
            cbwfx = sizeof(WAVEFORMATEX);
            pwfx  = (WAVEFORMATEX *)GlobalAllocPtr(GHND, sizeof(WAVEFORMATEX));

            if (pwfx == NULL)
                goto ERROR_OUTOFMEM;

            CreateWaveFormat(pwfx,fmt,(UINT)WAVE_MAPPER);
        }
        
        // destroy the current document
        DestroyWave();

        gcbWaveFormat = cbwfx;
        gpWaveFormat = pwfx;
    }

    if (gpWaveFormat == NULL)
        goto ERROR_OUTOFMEM;

    /* allocate an empty wave buffer */

    if (!AllocWaveBuffer(0L, TRUE, FALSE))
    {
        GlobalFreePtr(gpWaveFormat);
        gpWaveFormat = NULL;
        gcbWaveFormat = 0;
        goto RETURN_ERROR;
    }

    if (!AllocWaveHeaders(gpWaveFormat, guWaveHdrs))
        goto ERROR_OUTOFMEM;

    UpdateDisplay(TRUE);

    goto RETURN_SUCCESS;

ERROR_OUTOFMEM:
    ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
                IDS_APPTITLE, IDS_OUTOFMEM);
    goto RETURN_ERROR;

RETURN_ERROR:
    fOK = FALSE;

RETURN_SUCCESS:

#if 1
//bombay bug #1609  HackFix We're not getting focus on the right guy!
//                  UpdateDisplay should have done this

    if (IsWindowVisible(ghwndApp))
    {
        if (IsWindowEnabled(ghwndRecord))
            SetDlgFocus(ghwndRecord);
        else if (IsWindowEnabled(ghwndPlay))
            SetDlgFocus(ghwndPlay);
        else if (IsWindowEnabled(ghwndScroll))
            SetDlgFocus(ghwndScroll);
    }
#endif

    return fOK;
} // NewWave



/* fOK = DestroyWave()
 *
 * Destroy the current wave.  Do not access <gpWaveSamples> after this.
 *
 * On success, return TRUE.  On failure, display an error message
 * and return FALSE.
 */
BOOL FAR PASCAL
DestroyWave(void)
{
    DPF(TEXT("DestroyWave called\n"));

    if ((ghWaveIn != NULL) || (ghWaveOut != NULL))
        StopWave();
    if (gpWaveSamples != NULL)
    {
        DPF(TEXT("Freeing %x\n"),gpWaveSamples);
        GlobalFreePtr(gpWaveSamples);
    }
    if (gpWaveFormat != NULL)
        GlobalFreePtr(gpWaveFormat);

    if (gpszInfo != NULL)
        GlobalFreePtr(gpszInfo);

    //
    //      DON'T free wave headers!
    //
    ////////FreeWaveHeaders();

    glWaveSamples = 0L;
    glWaveSamplesValid = 0L;
    glWavePosition = 0L;
    gcbWaveFormat = 0; 

    gpWaveFormat = NULL;
    gpWaveSamples = NULL;
    gpszInfo = NULL;

#ifdef NEWPAUSE

    //***extra cautionary cleanup
    if (ghPausedWave && gfPaused)
    {
        if (gfWasPlaying)
            waveOutClose((HWAVEOUT)ghPausedWave);
        else
        if (gfWasRecording)
            waveInClose((HWAVEIN)ghPausedWave);
    }
    gfPaused = FALSE;
    ghPausedWave = NULL;

#endif

    return TRUE;
} /* DestroyWave */



UINT NEAR PASCAL SRecWaveOpen(LPHWAVE lphwave, LPWAVEFORMATEX lpwfx, BOOL fInput)
{
    UINT    uErr;

    if (!lphwave || !lpwfx)
        return (1);

#ifdef NEWPAUSE
    if (gfPaused && ghPausedWave)
    {
        /* we are in a paused state.  Restore the handle. */
        *lphwave = ghPausedWave;
        gfPaused = FALSE;
        ghPausedWave = NULL;
        return MMSYSERR_NOERROR;
    }
#endif

    *lphwave = NULL;

    //
    //  first open the wave device DISALLOWING sync drivers (sync drivers
    //  do not work with a streaming buffer scheme; which is our preferred
    //  mode of operation)
    //
    //  if we cannot open a non-sync driver, then we will attempt for
    //  a sync driver and disable the streaming buffer scheme..
    //

#if 0
    gfSyncDriver = FALSE;
#else
    //
    //  if the control key is down, then FORCE use of non-streaming scheme.
    //  all that this requires is that we set the gfSyncDriver flag
    //
    if (guWaveHdrs < 2)
        gfSyncDriver = TRUE;
    else
    {
#if 0

//********* Curtis, I don't know gfSyncDriver is always getting set now!
//********* please find out!  It probably has something to do with the
//********* hook for f1 help

        if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
            gfSyncDriver = TRUE;
        else
            gfSyncDriver = FALSE;
#else
        gfSyncDriver = FALSE;
#endif

    }
#endif

    if (fInput)
    {
        uErr = waveInOpen((LPHWAVEIN)lphwave
                        , (UINT)WAVE_MAPPER
                        , (LPWAVEFORMATEX)lpwfx
                        , (DWORD_PTR)ghwndApp
                        , 0L
                        , CALLBACK_WINDOW);
        if (uErr)
        {

/**** bug #967.  SPEAKER.DRV does not correctly return WAVERR_SYNC, but it
 ****            does return in error */
//            if (uErr == WAVERR_SYNC)
//            {

            uErr = waveInOpen((LPHWAVEIN)lphwave
                              , (UINT)WAVE_MAPPER
                              , (LPWAVEFORMATEX)lpwfx
                              , (DWORD_PTR)ghwndApp
                              , 0L
                              , CALLBACK_WINDOW|WAVE_ALLOWSYNC);
            if (uErr == MMSYSERR_NOERROR)
            {
                gfSyncDriver = TRUE;
            }

//            }

        }
    }
    else
    {
        uErr = waveOutOpen((LPHWAVEOUT)lphwave
                           , (UINT)WAVE_MAPPER
                           , (LPWAVEFORMATEX)lpwfx
                           , (DWORD_PTR)ghwndApp
                           , 0L
                           , CALLBACK_WINDOW);
        if (uErr)
        {

/**** bug #967.  SPEAKER.DRV does not correctly return WAVERR_SYNC, but it
 ****            does return in error */
////////////if (uErr == WAVERR_SYNC)
////////////{

                uErr = waveOutOpen((LPHWAVEOUT)lphwave
                                   , (UINT)WAVE_MAPPER
                                   , (LPWAVEFORMATEX)lpwfx
                                   , (DWORD_PTR)ghwndApp
                                   , 0L
                                   , CALLBACK_WINDOW|WAVE_ALLOWSYNC);
                if (uErr == MMSYSERR_NOERROR)
                {
                    gfSyncDriver = TRUE;
                }

////////////}

        }
    }
    return (uErr);
} /* SRecWaveOpen() */


/* SRecPlayBegin
**
** Sets
**     gdwCurrentBufferPos
**     gdwBytesPerBuffer
**     gfTimerStarted
**     fStopping
**     gfStoppingHard
**     grgbStatusColor
**     fCanPlay
**     glWavePosition
**     * gapWaveHdr[0]
** Calls
**     StopWave
**     UpdateDisplay
**     WriteWaveHeader
*/
BOOL NEAR PASCAL SRecPlayBegin(BOOL fSyncDriver)
{
    BOOL    fOK = TRUE;
    WORD    wIndex;
    UINT    uErr;

    //
    //
    //
    //
    gdwCurrentBufferPos = wfSamplesToBytes(gpWaveFormat, glWavePosition);

    if (fSyncDriver)
    {
        gdwBytesPerBuffer = gdwTotalLengthBytes - gdwCurrentBufferPos;

        uErr = WriteWaveHeader(gapWaveHdr[0],FALSE);

        if (uErr)
        {
            if (uErr == MMSYSERR_NOMEM)
            {
                // Prepare failed
                goto PB_ERROR_OUTOFMEM;
            }

            goto PB_ERROR_WAVEOUTWRITE;
        }
    }
    else
    {
        gdwBytesPerBuffer = wfTimeToSamples(gpWaveFormat, gwMSecsPerBuffer);
        gdwBytesPerBuffer = wfSamplesToBytes(gpWaveFormat, gdwBytesPerBuffer);

#if defined(_WIN32)
        StartPreTouchThread( &(gpWaveSamples[gdwCurrentBufferPos])
                           , gdwTotalLengthBytes - gdwCurrentBufferPos
                           );
#endif //_WIN32

        //
        // First wave header to be played is zero
        //
        fStopping = FALSE;

        waveOutPause(ghWaveOut);

        for (wIndex=0; wIndex < guWaveHdrs; wIndex++)
        {
            uErr = WriteWaveHeader(gapWaveHdr[wIndex],FALSE);
            if (uErr)
            {
                //
                // WriteWaveHeader will return -1 if there is no
                // more data to write. This is not an error!
                //
                // It indicates that the previous block was the
                // last one queued. Flag that we are doing cleanup
                // (just waiting for headers to complete) and save
                // which header is the last one to wait for.
                //
                if (uErr == (UINT)-1)
                {
                    if (wIndex == 0)
                    {
                        StopWave();
                        goto PB_RETURN_SUCCESS;
                    }

                    break;
                }

                //
                // If we run out of memory, but have already written
                // at least 2 wave headers, we can still keep going.
                // If we've written 0 or 1, we can't stream and will
                // stop.
                //
                if (uErr == MMSYSERR_NOMEM)
                {
                    if (wIndex > 1)
                        break;

                    // Prepare failed
                    StopWave();
                    goto PB_ERROR_OUTOFMEM;
                }

                StopWave();
                goto PB_ERROR_WAVEOUTWRITE;
            }
        }

        waveOutRestart(ghWaveOut);
    }

    /* update the display, including the status string */
    UpdateDisplay(TRUE);

    if (fSyncDriver)
    {
        /* do display updates */
        gfTimerStarted = (BOOL)SetTimer(ghwndApp, 1, TIMER_MSEC, NULL);
    }

    /* if user stops, focus will go back to "Play" button */
    gidDefaultButton = ID_PLAYBTN;

    fStopping = FALSE;
    goto PB_RETURN_SUCCESS;


PB_ERROR_WAVEOUTWRITE:

    ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
            IDS_APPTITLE, IDS_CANTOPENWAVEOUT);
    goto PB_RETURN_ERROR;

PB_ERROR_OUTOFMEM :
    ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
            IDS_APPTITLE, IDS_OUTOFMEM);
////goto PB_RETURN_ERROR;

PB_RETURN_ERROR:

    fOK = FALSE;

PB_RETURN_SUCCESS:

    return fOK;
} /* SRecPlayBegin() */



/* fOK = PlayWave()
 *
 * Start playing from the current position.
 *
 * On success, return TRUE.  On failure, display an error message
 * and return FALSE.
 */
BOOL FAR PASCAL
PlayWave(void)
{
    BOOL            fOK = TRUE;             // does this function succeed?
    UINT            uErr;

    DPF(TEXT("PlayWave called\n"));


    /* we are currently playing....*/
    if (ghWaveOut != NULL)
        return TRUE;

#if 1

//       Still trying to get this right with some bogus estimations
//       We shouldn't have to do this correction, but our conversions
//       are never 1:1

    // try to align us.
    glWavePosition = wfSamplesToSamples(gpWaveFormat,glWavePosition);
    {
        long lBlockInSamples;

        // if the distance between the glWaveSamplesValid and glWavePosition
        // is less than a "block"

        lBlockInSamples = wfBytesToSamples(gpWaveFormat,
                                           gpWaveFormat->nBlockAlign);

        if (glWaveSamplesValid - glWavePosition < lBlockInSamples)
            glWavePosition -= lBlockInSamples;
        if (glWavePosition < 0L)
            glWavePosition = 0L;
    }
#endif

    //
    //  refuse to play a zero length wave file.
    //
    if (glWaveSamplesValid == glWavePosition)
        goto RETURN_ERROR;

    /* stop playing or recording */
    StopWave();

    gdwTotalLengthBytes = wfSamplesToBytes(gpWaveFormat, glWaveSamples);

    /* open the wave output device */
    uErr = SRecWaveOpen((LPHWAVE)&ghWaveOut, gpWaveFormat, FALSE);
    if (uErr)
    {
        ghWaveOut = NULL;

        /* cannot open the waveform output device -- if the problem
        ** is that <gWaveFormat> is not supported, tell the user that
        ** 
        ** If the wave format is bad, then the play button is liable
        ** to be grayed, and the user is not going to be able to ask
        ** it to try to play, so we don't get here, so he doesn't get
        ** a decent diagnostic!!!
        */
        if (uErr == WAVERR_BADFORMAT)
        {
            ErrorResBox(ghwndApp, ghInst,
                        MB_ICONEXCLAMATION | MB_OK, IDS_APPTITLE,
                        IDS_BADOUTPUTFORMAT);
            goto RETURN_ERROR;
        }
        else
        {
            /* unknown error */
            goto ERROR_WAVEOUTOPEN;
        }
    }

    if (ghWaveOut == NULL)
        goto ERROR_WAVEOUTOPEN;

    /* start waveform output */

    // if fFineControl is still set then this is a pause as it has never
    // been properly stopped.  This means that we should keep remembering
    // the old position and stay in fine control mode, (else set new position)
    if (!fFineControl) {
        glSnapBackTo = glWavePosition;
        fFineControl = (0 > GetKeyState(VK_SHIFT));
    }

    glStartPlayRecPos = glWavePosition;

    //
    //  now kickstart the output...
    //

    if (SRecPlayBegin(gfSyncDriver) == FALSE)
    {
        waveOutClose(ghWaveOut);
        ghWaveOut = NULL;
        ghPausedWave = NULL;
        gfPaused = FALSE;
        goto RETURN_ERROR;
    }
    goto RETURN_SUCCESS;

ERROR_WAVEOUTOPEN:
    if (!waveInGetNumDevs() && !waveOutGetNumDevs()) {
        /* No recording or playback devices */
        ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
                    IDS_APPTITLE, IDS_NOWAVEFORMS);
    } else {
        ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
                    IDS_APPTITLE, IDS_CANTOPENWAVEOUT);
    }
    //goto RETURN_ERROR;

RETURN_ERROR:
    UpdateDisplay(TRUE);

    /* fix bug 4454 (WinWorks won't close) --EricLe */
    if (!IsWindowVisible(ghwndApp))
        PostMessage(ghwndApp, WM_CLOSE, 0, 0L);

    fOK = FALSE;

RETURN_SUCCESS:

    return fOK;
} // PlayWave



BOOL NEAR PASCAL SRecRecordBegin(BOOL fSyncDriver)
{
    UINT            uErr;
    long            lSamples;
    long            lOneSec;
    HCURSOR         hcurSave;
    DWORD           dwBytesAvailable;
    WORD            w;

    /* ok we go the wave device now allocate some memory to record into.
     * try to get at most 60sec from the current position.
     */

    lSamples = glWavePosition + wfTimeToSamples(gpWaveFormat, gdwBufferDeltaMSecs);
    lOneSec  = wfTimeToSamples(gpWaveFormat, 1000);

    hcurSave = SetCursor(LoadCursor(NULL, IDC_WAIT));

    //
    //  set the current buffer position (in BYTES) to the current position
    //  of the thumb (in SAMPLES)...
    //
    gdwCurrentBufferPos = wfSamplesToBytes(gpWaveFormat, glWavePosition);

    //
    //  compute the the size of each buffer for the async case only
    //
    if (!fSyncDriver)
    {
        gdwBytesPerBuffer = wfTimeToSamples(gpWaveFormat, gwMSecsPerBuffer);
        gdwBytesPerBuffer = wfSamplesToBytes(gpWaveFormat, gdwBytesPerBuffer);
    }

    for (;;)
    {
        DPF(TEXT("RecordWave trying %ld samples %ld.%03ldsec\n"), lSamples,  wfSamplesToTime(gpWaveFormat, lSamples)/1000, wfSamplesToTime(gpWaveFormat, lSamples) % 1000);

        if (lSamples < glWaveSamplesValid)
            lSamples = glWaveSamplesValid;

        if (AllocWaveBuffer(lSamples, FALSE, FALSE))
        {
            dwBytesAvailable    = wfSamplesToBytes(gpWaveFormat, glWaveSamples - glWavePosition);
            gdwTotalLengthBytes = dwBytesAvailable + gdwCurrentBufferPos;

            if (fSyncDriver)
            {
                //
                //  for the sync driver case, there is only one buffer--so
                //  set the size of our 'buffer' to be the total size...
                //
                gdwBytesPerBuffer = dwBytesAvailable;

                //
                //  try to prepare and add the complete buffer--if this fails,
                //  then we will try a smaller buffer..
                //
                uErr = WriteWaveHeader(gapWaveHdr[0], FALSE);
                if (uErr == 0)
                    break;
            }
            else
            {
                //
                //  Make sure we can prepare enough wave headers to stream
                //  even if realloc succeeded
                //
                for (w = 0; w < guWaveHdrs; w++)
                {
                    uErr = WriteWaveHeader(gapWaveHdr[w], FALSE);
                    if (uErr)
                    {
                        //
                        //  WriteWaveHeader will return -1 if there is no
                        //  more data to write. This is not an error!
                        //
                        //  It indicates that the previous block was the
                        //  last one queued. Flag that we are doing cleanup
                        //  (just waiting for headers to complete) and save
                        //  which header is the last one to wait for.
                        //
                        if (uErr == (UINT)-1)
                        {
                            if (w == 0)
                            {
                                StopWave();
                                return (TRUE);
                            }

                            break;
                        }

                        //
                        //  If we run out of memory, but have already written
                        //  at least 2 wave headers, we can still keep going.
                        //  If we've written 0 or 1, we can't stream and will
                        //  stop.
                        //
                        if (uErr == MMSYSERR_NOMEM)
                        {
                            if (w > 1)
                                break;

                            StopWave();
                            goto BEGINREC_ERROR_OUTOFMEM;
                        }

                        goto BEGINREC_ERROR_WAVEINSTART;
                    }
                }

                //
                //  we wrote enough (we think), so break out of the realloc
                //  loop
                //
                break;
            }
        }

        //
        // we can't get the memory we want, so try 25% less.
        //
        if (lSamples <= glWaveSamplesValid ||
            lSamples < glWavePosition + lOneSec)
        {
            SetCursor(hcurSave);
            goto BEGINREC_ERROR_OUTOFMEM;
        }

        lSamples = glWavePosition + ((lSamples-glWavePosition)*75)/100;
    }

    SetCursor(hcurSave);

    glStartPlayRecPos = glWavePosition;

    BeginWaveEdit();

    if (waveInStart(ghWaveIn) != 0)
        goto BEGINREC_ERROR_WAVEINSTART;

    /* update the display, including the status string */
    UpdateDisplay(TRUE);

    //
    //  only start timer in the sync driver case--async case we use the
    //  buffers being posted back as our display update timer...
    //
    if (fSyncDriver)
    {
        /* do display updates */
        gfTimerStarted = (BOOL)SetTimer(ghwndApp, 1, TIMER_MSEC, NULL);
    }

    /* if user stops, focus will go back to "Record" button */
    gidDefaultButton = ID_RECORDBTN;

    fStopping = FALSE;

    return TRUE;

BEGINREC_ERROR_OUTOFMEM:
    ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
            IDS_APPTITLE, IDS_OUTOFMEM);
    goto BEGINREC_ERROR;


BEGINREC_ERROR_WAVEINSTART:
    /* This is necessary to un-add the buffer */
    waveInReset(ghWaveIn);

    EndWaveEdit(FALSE);

    /* The wave device will get closed in WaveInData() */
//    goto BEGINREC_ERROR;

BEGINREC_ERROR:

    return FALSE;

} /* SRecRecordBegin() */




/* fOK = RecordWave()
 *
 * Start recording at the current position.
 *
 * On success, return TRUE.  On failure, display an error message
 * and return FALSE.
 */
BOOL FAR PASCAL
RecordWave(void)
{
    UINT uErr;

    /* stop playing or recording */
    StopWave();

    glWavePosition = wfSamplesToSamples(gpWaveFormat, glWavePosition);

    /* open the wave input device */
    uErr = SRecWaveOpen((LPHWAVE)&ghWaveIn, gpWaveFormat, TRUE);
    if (uErr)
    {

        /* cannot open the waveform input device -- if the problem
         * is that <gWaveFormat> is not supported, advise the user to
         * do File/New to record; if the problem is that recording is
         * not supported even at 11KHz, tell the user
         */
        if (uErr == WAVERR_BADFORMAT)
        {
            WAVEFORMATEX    wf;

            /* is 11KHz mono recording supported? */
            if (!CreateWaveFormat(&wf, FMT_11k|FMT_MONO|FMT_8BIT,
                                  (UINT)WAVE_MAPPER))
            {
                /* even 11KHz mono recording is not supported */
                ErrorResBox(ghwndApp, ghInst,
                            MB_ICONEXCLAMATION | MB_OK, IDS_APPTITLE,
                            IDS_INPUTNOTSUPPORT);
                goto RETURN_ERROR;
            }
            else
            {
                /* 11KHz mono is supported, but the format
                 * of the current file is not supported
                 */
                ErrorResBox(ghwndApp, ghInst,
                            MB_ICONEXCLAMATION | MB_OK, IDS_APPTITLE,
                            IDS_BADINPUTFORMAT);
                goto RETURN_ERROR;
            }
        }
        else
        {
            /* unknown error */
            goto ERROR_WAVEINOPEN;
        }
    }

    if (ghWaveIn == NULL)
        goto ERROR_WAVEINOPEN;

    if (!SRecRecordBegin(gfSyncDriver))
        goto RETURN_ERROR;

    goto RETURN_SUCCESS;

ERROR_WAVEINOPEN:
    if (!waveInGetNumDevs() && !waveOutGetNumDevs()) {
        /* No recording or playback devices */
        ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
                    IDS_APPTITLE, IDS_NOWAVEFORMS);
    } else {
        ErrorResBox(ghwndApp, ghInst, MB_ICONEXCLAMATION | MB_OK,
                    IDS_APPTITLE, IDS_CANTOPENWAVEIN);
    }

    // goto RETURN_ERROR;

RETURN_ERROR:
    if (ghWaveIn)
        waveInClose(ghWaveIn);
    ghWaveIn = NULL;
    ghPausedWave = NULL;

    if (glWaveSamples > glWaveSamplesValid)
    {
        /* reallocate the wave buffer to be small */
        AllocWaveBuffer(glWaveSamplesValid, TRUE, TRUE);
    }

    UpdateDisplay(TRUE);

RETURN_SUCCESS:
    return TRUE;
} /* RecordWave */





/* YieldStop(void)
 *
 *      Yeild for mouse and keyboard messages so that the stop can be
 *      processed.
 */

BOOL NEAR PASCAL YieldStop(void)
{
    BOOL    f;
    MSG         msg;

    f = FALSE;

    // Perhaps someone might deign to write a line or two
    // to explain why this loop is here twice and what it's actually doing?

    while (PeekMessage(&msg, ghwndStop, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE | PM_NOYIELD))
    {
        f = TRUE;
    TranslateMessage(&msg);
    DispatchMessage(&msg);
    }

    while (PeekMessage(&msg, ghwndStop, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE | PM_NOYIELD))
    {
        f = TRUE;
    TranslateMessage(&msg);
    DispatchMessage(&msg);
    }

    return (f);
} /* YieldStop() */


BOOL NEAR PASCAL IsAsyncStop(void)
{
    //
    //  we need to check for the esc key being pressed--BUT, we don't want
    //  to stop unless ONLY the esc key is pressed. so if someone tries to
    //  bring up task man with xxx-esc, it will not stop the playing wave..
    //
    if (GetAsyncKeyState(VK_ESCAPE) & 0x8000)
    {
        if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) ||
            (GetAsyncKeyState(VK_MENU)    & 0x8000) ||
            (GetAsyncKeyState(VK_SHIFT)   & 0x8000))
        {
            return (FALSE);
        }

        //
        //  looks like only the esc key..
        //
        return (TRUE);
    }

    return (FALSE);
} /* IsAsyncStop() */




/* WaveOutDone(hWaveOut, pWaveHdr)
 *
 * Called when wave block with header <pWaveHdr> is finished playing.
 * This function causes playing to end.
 */
void FAR PASCAL
WaveOutDone(
HWAVEOUT        hWaveOut,                       // wave out device
LPWAVEHDR       pWaveHdr)               // wave header
{
    BOOL        f;
    MSG         msg;
    WORD        w;
    BOOL        fStillMoreToGo;
    UINT        u;

////DPF(TEXT("WaveOutDone()\n"));

    //
    //  check for plunger message--if we get this message, then we are done
    //  and need to close the wave device if it is still open...
    //
    if (pWaveHdr == NULL) {

#ifdef NEWPAUSE
        if (!gfPausing) {
            if (ghWaveOut) {
                waveOutClose(ghWaveOut);
                ghWaveOut = NULL;
                ghPausedWave = NULL;
            }
        }
        else
        {
            gfPaused = TRUE;
            ghWaveOut = NULL;
        }
#else
        if (ghWaveOut) {
            waveOutClose(ghWaveOut);
            ghWaveOut = NULL;
        }
#endif
    } else /* pWaveHdr!=NULL */
    if (gfSyncDriver) {
        WriteWaveHeader(pWaveHdr, TRUE);

        //
        //  !! must do this for sync drivers !!
        //
        if (!gfStoppingHard)
            /* I really don't understand the details of this yet.
            ** What you might call the random stab method of programming!
            ** Laurie
            */
            glWavePosition = glWaveSamplesValid;

#ifdef NEWPAUSE
        if (!gfPausing) {
            waveOutClose(ghWaveOut);
            ghWaveOut = NULL;
            ghPausedWave = NULL;
        } else {
            ghWaveOut = NULL;
            gfPaused = TRUE;
        }
#else
        waveOutClose(ghWaveOut);
        ghWaveOut = NULL;
#endif
    } else { /* pWaveHdr!=NULL & !gfSyncDriver */
        if (!fStopping) {
            while (1) {
                glWavePosition += wfBytesToSamples(gpWaveFormat, pWaveHdr->dwBufferLength);

                //
                // Go into cleanup mode (stop writing new data) on any error
                //
                u = WriteWaveHeader(pWaveHdr, FALSE);
                if (u) {
                    if (u == (UINT)-1) {
                        /* pWaveHdr!=NULL & !gfSyncDriver
                           & WriteWaveHeader() returned -1
                        */
                        fStopping = TRUE;

                        //
                        //  we cannot assume that the wave position is going
                        //  to end up exactly at the end with compressed data
                        //  because of this, we cannot do this postion compare
                        //  to see if we are 'completely' done (all headers
                        //  posted back, etc
                        //
                        //  so we jump to a piece of code that searches for
                        //  any buffers that are still outstanding...
                        //
#if 0
                        if (glWavePosition >= glWaveSamplesValid)
                        {
                            waveOutClose(ghWaveOut);
                            ghWaveOut = NULL;
                        }
                        break;
#else
                        fStillMoreToGo = FALSE;
                        goto KLUDGE_FOR_NOELS_BUG;
#endif
                    }

                    DPF(TEXT("WaveOutDone: CRITICAL ERROR ON WRITING BUFFER [%.04Xh]\n"), u);
                    StopWave();
                } else {
                    if (IsAsyncStop()) {
                        StopWave();
                        return;
                    }
                    if (YieldStop()) {
                        return;
                    }
                }

                f = PeekMessage(&msg, ghwndApp, MM_WOM_DONE, MM_WOM_DONE,
                                    PM_REMOVE | PM_NOYIELD);
                if (!f)
                    break;

                //
                //  don't let plunger msg mess us up!
                //
                if (msg.lParam == 0L)
                    break;

                pWaveHdr = (LPWAVEHDR)msg.lParam;
            }
        } else {
            fStillMoreToGo = FALSE;

            if (gfStoppingHard) {
                while (1) {
                    DPF(TEXT("HARDSTOP PLAY: another one bites the dust!\n"));

                    WriteWaveHeader(pWaveHdr, TRUE);

                    f = PeekMessage(&msg, ghwndApp, MM_WOM_DONE, MM_WOM_DONE,
                                        PM_REMOVE | PM_NOYIELD);

                    if (!f)
                        break;

                    //
                    //  don't let plunger msg mess us up!
                    //
                    if (msg.lParam == 0L)
                        break;

                    pWaveHdr = (LPWAVEHDR)msg.lParam;
                }
            } else {
                glWavePosition += wfBytesToSamples(gpWaveFormat, pWaveHdr->dwBufferLength);

                WriteWaveHeader(pWaveHdr, TRUE);

KLUDGE_FOR_NOELS_BUG:
                for (w = 0; w < guWaveHdrs; w++) {
                    if (gapWaveHdr[w]->dwFlags & WHDR_PREPARED) {
                        DPF(TEXT("PLAY: still more headers outstanding...\n"));
                        fStillMoreToGo = TRUE;
                        break;
                    }
                }
            }

            if (!fStillMoreToGo) {
                //
                //  if the user did not push stop (ie we played through
                //  normally) put the position at the end of the wave.
                //
                //  note we need to do this for sync drivers and compressed
                //  wave's
                //
                if (!gfStoppingHard)
                    glWavePosition = glWaveSamplesValid;
#ifdef NEWPAUSE
                if (!gfPausing) {
                    waveOutClose(ghWaveOut);
                    ghWaveOut = NULL;
                    ghPausedWave = NULL;
                } else {
                    ghWaveOut = NULL;
                    gfPaused = TRUE;
                }
#else
                waveOutClose(ghWaveOut);
                ghWaveOut = NULL;
#endif
                {
                    if (gfCloseAtEndOfPlay)
                        PostMessage(ghwndApp, WM_CLOSE, 0, 0L);
                }
            }
        }
    }

    UpdateDisplay(TRUE);

    //
    //
    //
    //
    if (ghWaveOut == NULL) {
        if (gfTimerStarted) {
            KillTimer(ghwndApp, 1);
            gfTimerStarted = FALSE;
        }
        SnapBack();
    }

    /* If we were showing the window temporarily while playing,
        hide it now. */

    if (ghWaveOut == NULL && gfHideAfterPlaying) {
        DPF(TEXT("Done playing, so hide window.\n"));
        ShowWindow(ghwndApp, SW_HIDE);
    }

    if (ghWaveOut == NULL && !IsWindowVisible(ghwndApp))
        PostMessage(ghwndApp, WM_CLOSE, 0, 0L);

} /* WaveOutDone */



/* WaveInData(hWaveIn, pWaveHdr)
 *
 * Called when wave block with header <pWaveHdr> is finished being
 * recorded.  This function causes recording to end.
 */
void FAR PASCAL
WaveInData(
HWAVEIN         hWaveIn,                // wave in device
LPWAVEHDR       pWaveHdr)               // wave header
{
    BOOL        f;
    MSG         msg;
    WORD        w;
    BOOL        fStillMoreToGo;
    UINT        u;

    //
    //  check for plunger message--if we get this message, then we are done
    //  and need to close the wave device if it is still open...
    //
    if (pWaveHdr == NULL)
    {

//*** BOMBAY:1370 how do we pause without closing the handle?

#ifdef NEWPAUSE

        if (!gfPausing)
        {
            if (ghWaveIn)
            {
                waveInClose(ghWaveIn);
                ghWaveIn = NULL;
                ghPausedWave = NULL;
            }
        }
        else
        {
            gfPaused = TRUE;
            ghWaveIn = NULL;
        }

#else

        if (ghWaveIn)
        {
            waveInClose(ghWaveIn);
            ghWaveIn = NULL;
        }

#endif

    }
    else if (gfSyncDriver)
    {
        glWavePosition = glStartPlayRecPos + wfBytesToSamples(gpWaveFormat,
                                                pWaveHdr->dwBytesRecorded);
        if (glWaveSamplesValid < glWavePosition)
            glWaveSamplesValid = glWavePosition;

        WriteWaveHeader(pWaveHdr, TRUE);

//*** BOMBAY:1370 How do we pause without closing the handle?

#ifdef NEWPAUSE

        if (!gfPausing)
        {
            waveInClose(ghWaveIn);
            ghWaveIn = NULL;
            ghPausedWave = NULL;
        }
        else
        {
            ghWaveIn = NULL;
            gfPaused = TRUE;
        }

#else

        waveInClose(ghWaveIn);
        ghWaveIn = NULL;

#endif

    }
    else
    {
        if (!fStopping)
        {
            while (1)
            {
                glWavePosition += wfBytesToSamples(gpWaveFormat, pWaveHdr->dwBytesRecorded);

                //
                //  go into cleanup mode (stop writing new data) on any error
                //
                u = WriteWaveHeader(pWaveHdr, FALSE);
                if (u)
                {
                    //
                    //  if the return value is '-1' then we are out of data
                    //  space--but probably have headers outstanding so we
                    //  need to wait for all headers to come in before
                    //  shutting down.
                    //
                    if (u == (UINT)-1)
                    {
                        DPF(TEXT("WaveInData: stopping cuz out of data space\n"));
                        fStopping = TRUE;
                        break;
                    }

                    DPF(TEXT("WaveInData: CRITICAL ERROR ON ADDING BUFFER [%.04Xh]\n"), u);
                    StopWave();
                }
                else
                {
                    if (IsAsyncStop())
                    {
                        StopWave();
                        return;
                    }

                    if (YieldStop())
                        return;
                }

                f = PeekMessage(&msg, ghwndApp, MM_WIM_DATA, MM_WIM_DATA,
                                    PM_REMOVE | PM_NOYIELD);
                if (!f)
                    break;

                //
                //  don't let plunger msg mess us up!
                //
                if (msg.lParam == 0L)
                    break;

                pWaveHdr = (LPWAVEHDR)msg.lParam;
            }
        }
        else
        {
            fStillMoreToGo = FALSE;

            if (gfStoppingHard)
            {
                while (1)
                {
                    DPF(TEXT("HARDSTOP RECORD: another one bites the dust!\n"));

                    //
                    //  NOTE! update the position cuz info could have been
                    //  recorded and we have not received its callback yet..
                    //  length will be zero if not used--so this works great
                    //
                    glWavePosition += wfBytesToSamples(gpWaveFormat, pWaveHdr->dwBytesRecorded);
                    WriteWaveHeader(pWaveHdr, TRUE);

                    f = PeekMessage(&msg, ghwndApp, MM_WIM_DATA, MM_WIM_DATA,
                                        PM_REMOVE | PM_NOYIELD);

                    if (!f)
                        break;

                    //
                    //  don't let plunger msg mess us up!
                    //
                    if (msg.lParam == 0L)
                        break;

                    pWaveHdr = (LPWAVEHDR)msg.lParam;
                }
            }
            else
            {
                glWavePosition += wfBytesToSamples(gpWaveFormat, pWaveHdr->dwBytesRecorded);

                //
                //  we're stopping, so get this header unprepared and proceed
                //  to shut this puppy down!
                //
                WriteWaveHeader(pWaveHdr, TRUE);

                for (w = 0; w < guWaveHdrs; w++)
                {
                    if (gapWaveHdr[w]->dwFlags & WHDR_PREPARED)
                    {
                        DPF(TEXT("RECORD: still more headers outstanding...\n"));
                        fStillMoreToGo = TRUE;
                        break;
                    }
                }
            }

            if (!fStillMoreToGo)
            {
//*** BOMBAY:1370 How do we pause without closing the handle?

#ifdef NEWPAUSE
                if (!gfPausing)
                {
                    waveInClose(ghWaveIn);
                    ghWaveIn = NULL;
                    ghPausedWave = NULL;
                }
                else
                {
                    ghWaveIn = NULL;
                    gfPaused = TRUE;
                }
#else
                waveInClose(ghWaveIn);
                ghWaveIn = NULL;
#endif
            }
        }
    }

    //
    //  update <glWaveSamplesValid>
    //
    UpdateDisplay(TRUE);

    //
    //  if we closed the wave device, then we are completely done so do what
    //  we do when we are completely done...
    //
    //  NOTE! we must have already called UpdateDisplay(TRUE) before doing
    //  the following!
    //
    if (ghWaveIn == NULL)
    {
        if (gfTimerStarted)
        {
            KillTimer(ghwndApp, 1);
            gfTimerStarted = FALSE;
        }

        if (glWaveSamples > glWaveSamplesValid)
        {
            /* reallocate the wave buffer to be small */
            AllocWaveBuffer(glWaveSamplesValid, TRUE, TRUE);
        }

        if (pWaveHdr)
        {
            /* ask user to save file if they close it */
            EndWaveEdit(TRUE);
        }
        SnapBack();
    }
} /* WaveInData */

/*
 *  @doc INTERNAL SOUNDREC
 *
 *  @api void FAR PASCAL | FinishPlay | Processes messages until a stop
 *      has flushed all WOM_DONE/WIM_DONE messages out of the message queue.
 *
 *  @rdesc  None.
 */
void FAR PASCAL FinishPlay(
        void)
{
        MSG             msg;
        while (GetMessage(&msg, NULL, 0, 0))
        {
                if (!TranslateAccelerator(ghwndApp, ghAccel, &msg))
                {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                }

#ifdef NEWPAUSE
//        Why is this commented out?
                
//        if (gfPausing && gfPaused)
//            break;
#endif
                if ((ghWaveOut == NULL) && (ghWaveIn == NULL))
                        break;
        }
} /* FinishPlay() */



/* StopWave()
 *
 * Request waveform recording or playback to stop.
 */
void FAR PASCAL
     StopWave(void)
{
    DPF(TEXT("------------StopWave() called!\n"));

    if (ghWaveOut != NULL)
    {
        waveOutReset(ghWaveOut);

        //
        //  post a 'plunger' message that will guarantee that at least one
        //  message goes through so we stop even in bizarre cases...
        //
        if (!gfSyncDriver)
        {
            DPF(TEXT("Post Plunger (WOM)\n"));
            PostMessage(ghwndApp, MM_WOM_DONE, 0, 0L);
        }
        fStopping      = TRUE;  // the pre-touch thread periscopes this flag
        if (ghPreTouch!=NULL){
            WaitForSingleObject(ghPreTouch, INFINITE);
            CloseHandle(ghPreTouch);
            ghPreTouch = NULL;
        }
    }
    else if (ghWaveIn != NULL)
    {
        waveInReset(ghWaveIn);
        //
        //  post a 'plunger' message that will guarantee that at least one
        //  message goes through so we stop even in bizarre cases...
        //
        if (!gfSyncDriver)
        {
            DPF(TEXT("Post Plunger (WIM)\n"));
            PostMessage(ghwndApp, MM_WIM_DATA, 0, 0L);
        }
    }
    else
        return;

    fStopping      = TRUE;
    gfStoppingHard = TRUE;

    /* get messages from event queue and dispatch them,
     * until the MM_WOM_DONE or MM_WIM_DATA message is
     * processed
     */
    FinishPlay();
    gfStoppingHard = FALSE;

// Should StopWave() be calling UpdateDisplay()?
}


#if 0 // this is obsolete
/* EnableButtonRedraw(fAllowRedraw)
 *
 * Allow/disallow the buttons to redraw, depending on <fAllowRedraw>.
 * This is designed to reduce button flicker.
 */
void NEAR PASCAL
     EnableButtonRedraw(BOOL fAllowRedraw)
{
    SendMessage(ghwndPlay, WM_SETREDRAW, fAllowRedraw, 0);
    SendMessage(ghwndStop, WM_SETREDRAW, fAllowRedraw, 0);
    SendMessage(ghwndRecord, WM_SETREDRAW, fAllowRedraw, 0);

    if (fAllowRedraw)
    {
        InvalidateRect(ghwndPlay, NULL, FALSE);
        InvalidateRect(ghwndStop, NULL, FALSE);
        InvalidateRect(ghwndRecord, NULL, FALSE);
    }
}
#endif //0  - obsolete function


/* UpdateDisplay(fStatusChanged)
 *
 * Update the current position and file length on the display.
 * If <fStatusChanged> is TRUE, also update the status line and button
 * enable/disable state.
 *
 * As a side effect, update <glWaveSamplesValid> if <glWavePosition>
 * is greater than <glWaveSamplesValid>.
 */
void FAR PASCAL
     UpdateDisplay(
                    BOOL fStatusChanged)         // update status line
{
   MMTIME          mmtime;
   UINT            uErr;
   int             id;
   TCHAR           ach[120];
   long            lTime;
   long            lLen;
   int             iPos;
   HWND            hwndFocus;
   BOOL            fCanPlay;
   BOOL            fCanRecord;

   hwndFocus = GetFocus();

   if (fStatusChanged)
   {

      // EnableButtonRedraw(FALSE);

      /* update the buttons and the status line */
      if (ghWaveOut != NULL)
      {
         /* we are now playing */
         id = IDS_STATUSPLAYING;
         grgbStatusColor = RGB_PLAY;

         SendMessage(ghwndPlay,BM_SETCHECK,TRUE,0L);

         EnableWindow(ghwndPlay, FALSE);
         EnableWindow(ghwndStop, TRUE);
         EnableWindow(ghwndRecord, FALSE);

         if ((hwndFocus == ghwndPlay) ||  (hwndFocus == ghwndRecord))
            if (IsWindowVisible(ghwndApp))
               SetDlgFocus(ghwndStop);
      }
      else
      if (ghWaveIn != NULL)
      {
         /* we are now recording */
         id = IDS_STATUSRECORDING;
         grgbStatusColor = RGB_RECORD;

         SendMessage(ghwndRecord,BM_SETCHECK,TRUE,0L);
         EnableWindow(ghwndPlay, FALSE);
         EnableWindow(ghwndStop, TRUE);
         EnableWindow(ghwndRecord, FALSE);

         if ((hwndFocus == ghwndPlay) ||  (hwndFocus == ghwndRecord))
            if (IsWindowVisible(ghwndApp))
               SetDlgFocus(ghwndStop);

      }
      else
      {
         fCanPlay = (0 == waveOutOpen(NULL
                                      , (UINT)WAVE_MAPPER
                                      , (LPWAVEFORMATEX)gpWaveFormat
                                      , 0L
                                      , 0L
                                      , WAVE_FORMAT_QUERY|WAVE_ALLOWSYNC));

         fCanRecord = (0 == waveInOpen(NULL
                                       , (UINT)WAVE_MAPPER
                                       , (LPWAVEFORMATEX)gpWaveFormat
                                       , 0L
                                       , 0L
                                       , WAVE_FORMAT_QUERY|WAVE_ALLOWSYNC));

         /* we are now stopped */
         id = IDS_STATUSSTOPPED;
         grgbStatusColor = RGB_STOP;

         //
         //  'un-stick' the buttons if they are currently
         //  stuck
         //
         SendMessage(ghwndPlay,BM_SETCHECK,FALSE,0L);
         SendMessage(ghwndRecord,BM_SETCHECK,FALSE,0L);

         EnableWindow(ghwndPlay, fCanPlay && glWaveSamplesValid > 0);
         EnableWindow(ghwndStop, FALSE);
         EnableWindow(ghwndRecord, fCanRecord);

         if (hwndFocus && !IsWindowEnabled(hwndFocus) &&
            GetActiveWindow() == ghwndApp && IsWindowVisible(ghwndApp))
         {
            if (gidDefaultButton == ID_RECORDBTN && fCanRecord)
               SetDlgFocus(ghwndRecord);
            else if (fCanPlay && glWaveSamplesValid > 0)
               SetDlgFocus(ghwndPlay);
            else
               SetDlgFocus(ghwndScroll);
         }
      }

   }
   // EnableButtonRedraw(TRUE);
   if (ghWaveOut != NULL || ghWaveIn != NULL)
   {
      if (gfTimerStarted)
      {
         glWavePosition = 0L;
         mmtime.wType = TIME_SAMPLES;

         if (ghWaveOut != NULL)
            uErr = waveOutGetPosition(ghWaveOut, &mmtime, sizeof(mmtime));
         else
            uErr = waveInGetPosition(ghWaveIn, &mmtime, sizeof(mmtime));

         if (uErr == MMSYSERR_NOERROR)
         {
            switch (mmtime.wType)
            {
         case TIME_SAMPLES:
            glWavePosition = glStartPlayRecPos + mmtime.u.sample;
            break;

         case TIME_BYTES:
            glWavePosition = glStartPlayRecPos + wfBytesToSamples(gpWaveFormat, mmtime.u.cb);
            break;
            }
         }
      }
   }

   /* SEMI-HACK: Guard against bad values */
   if (glWavePosition < 0L) {
      DPF(TEXT("Position before zero!\n"));
      glWavePosition = 0L;
   }

   if (glWavePosition > glWaveSamples) {
      DPF(TEXT("Position past end!\n"));
      glWavePosition = glWaveSamples;
   }

   /* side effect: update <glWaveSamplesValid> */
   if (glWaveSamplesValid < glWavePosition)
      glWaveSamplesValid = glWavePosition;

   /* display the current wave position */
   lTime = wfSamplesToTime(gpWaveFormat, glWavePosition);
   if (gfLZero || ((int)(lTime/1000) != 0))
      wsprintf(ach, aszPositionFormat, (int)(lTime/1000), chDecimal, (int)((lTime/10)%100));
   else
      wsprintf(ach, aszNoZeroPositionFormat, chDecimal, (int)((lTime/10)%100));

   SetDlgItemText(ghwndApp, ID_CURPOSTXT, ach);

   /* display the current wave length */

   //
   //  changes whether the right-hand status box displays max length or current
   //  position while recording... the status box used to display the max
   //  length... if the status box gets added back for some reason, then we
   //  MAY want to change this back to the old way..
   //
#if 1
   lLen = ghWaveIn ? glWaveSamples : glWaveSamplesValid;
#else
   lLen = glWaveSamplesValid;
#endif
   lTime = wfSamplesToTime(gpWaveFormat, lLen);

   if (gfLZero || ((int)(lTime/1000) != 0))
      wsprintf(ach, aszPositionFormat, (int)(lTime/1000), chDecimal, (int)((lTime/10)%100));
   else
      wsprintf(ach, aszNoZeroPositionFormat, chDecimal, (int)((lTime/10)%100));

   SetDlgItemText(ghwndApp, ID_FILELENTXT, ach);

   /* update the wave display */
   InvalidateRect(ghwndWaveDisplay, NULL, fStatusChanged);
   UpdateWindow(ghwndWaveDisplay);

   /* update the scroll bar position */
   if (glWaveSamplesValid > 0)
      iPos = (int)MulDiv((DWORD) SCROLL_RANGE, glWavePosition, lLen);
   else
      iPos = 0;

   //
   // windows will re-draw the scrollbar even
   // if the position does not change.
   //
#if 0
   if (iPos != GetScrollPos(ghwndScroll, SB_CTL))
      SetScrollPos(ghwndScroll, SB_CTL, iPos, TRUE);
   //        if (iPos != GetScrollPos(ghwndScroll, SB_CTL))
   //       SendMessage(ghwndScroll, TBM_SETPOS, TRUE, (LPARAM)(WORD)iPos);
#endif

   // Now we're using a much nicer trackbar
   // SetScrollPos(ghwndScroll, SB_CTL, iPos, TRUE);
   SendMessage(ghwndScroll,TBM_SETPOS, TRUE, (LPARAM)(WORD)iPos);  // WORD worries me. LKG. ???
   SendMessage(ghwndScroll,TBM_SETRANGEMAX, 0, (glWaveSamplesValid > 0)?SCROLL_RANGE:0);

   EnableWindow(ghwndForward, glWavePosition < glWaveSamplesValid);
   EnableWindow(ghwndRewind,  glWavePosition > 0);

   if (hwndFocus == ghwndForward && glWavePosition >= glWaveSamplesValid)
      SetDlgFocus(ghwndRewind);

   if (hwndFocus == ghwndRewind && glWavePosition == 0)
      SetDlgFocus(ghwndForward);

#ifdef DEBUG
   if ( ((ghWaveIn != NULL) || (ghWaveOut != NULL)) &&
      (gapWaveHdr[0]->dwFlags & WHDR_DONE) )
      //!!            DPF2(TEXT("DONE BIT SET!\n"));
      ;
#endif
} /* UpdateDisplay */