if (*ppwfxSrc != NULL)
                {
                GlobalFree(*ppwfxSrc);
                *ppwfxSrc = NULL;
                }

        if (*phmmio != NULL)
                {
                mmioClose(*phmmio, 0);
                *phmmio = NULL;
                }

        return(0);

}

/*      This routine will create a wave file for writing.  This will automatically overwrite any
        existing file with the same name, so be careful and check before hand!!!
        pszFileName     - Pointer to filename to write.
        phmmioOut               - Pointer to HMMIO handle that is used for further writes
        pwfxDest                - Valid waveformatex destination structure.
        pckOut                  - Pointer to be set with the MMCKINFO.
        pckOutRIFF              - Pointer to be set with the RIFF info.

*/
int WaveCreateFile(
                        char *pszFileName,                              // (IN)
                        HMMIO *phmmioOut,                               // (OUT)
                        WAVEFORMATEX *pwfxDest,                 // (IN)
                        MMCKINFO *pckOut,                               // (OUT)
                        MMCKINFO *pckOutRIFF                    // (OUT)

                        )
{
            
        int             nError;                         // Return value.
        DWORD           dwFactChunk;            // Contains the actual fact chunk. Garbage until WaveCloseWriteFile.
        MMCKINFO        ckOut1;

        dwFactChunk = (DWORD)-1;
        nError = 0;

        *phmmioOut = mmioOpen(pszFileName, NULL,
                        MMIO_ALLOCBUF | MMIO_READWRITE|MMIO_CREATE);

    if (*phmmioOut == NULL)
                {
                nError = ER_CANNOTWRITE;
        goto ERROR_CANNOT_WRITE;    // cannot save WAVE file
                }

    /* Create the output file RIFF chunk of form type 'WAVE'.
     */
    pckOutRIFF->fccType = mmioFOURCC('W', 'A', 'V', 'E');       
        pckOutRIFF->cksize = 0; 
    if ((nError = mmioCreateChunk(*phmmioOut, pckOutRIFF, MMIO_CREATERIFF)) != 0)
                {
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                }

    /* We are now descended into the 'RIFF' chunk we just created.
     * Now create the 'fmt ' chunk. Since we know the size of this chunk,
     * specify it in the MMCKINFO structure so MMIO doesn't have to seek
     * back and set the chunk size after ascending from the chunk.
     */
    pckOut->ckid = mmioFOURCC('f', 'm', 't', ' ');
    pckOut->cksize = sizeof(PCMWAVEFORMAT);   // we know the size of this ck.
    if ((nError = mmioCreateChunk(*phmmioOut, pckOut, 0)) != 0)
                {
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                }

    /* Write the PCMWAVEFORMAT structure to the 'fmt ' chunk if its that type. */
    if (pwfxDest->wFormatTag == WAVE_FORMAT_PCM)
                {
            if (mmioWrite(*phmmioOut, (HPSTR) pwfxDest, sizeof(PCMWAVEFORMAT))
                != sizeof(PCMWAVEFORMAT))
                        {
                        nError = ER_CANNOTWRITE;
                goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                        }
                }
        
        else 
                {
                // Write the variable length size.
                if ((UINT)mmioWrite(*phmmioOut, (HPSTR) pwfxDest, sizeof(*pwfxDest)+pwfxDest->cbSize)
                != (sizeof(*pwfxDest)+pwfxDest->cbSize))
                        {
                        nError = ER_CANNOTWRITE;
                goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                        } 

                }  

    /* Ascend out of the 'fmt ' chunk, back into the 'RIFF' chunk.
     */
    if ((nError = mmioAscend(*phmmioOut, pckOut, 0)) != 0)
                {
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                }

        // Now create the fact chunk, not required for PCM but nice to have.  This is filled
        // in when the close routine is called.
        ckOut1.ckid = mmioFOURCC('f', 'a', 'c', 't');
        ckOut1.cksize = 0;
    if ((nError = mmioCreateChunk(*phmmioOut, &ckOut1, 0)) != 0)
                {
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                }

        if (mmioWrite(*phmmioOut, (HPSTR)&dwFactChunk, sizeof(dwFactChunk)) != sizeof(dwFactChunk))
                {
                nError = ER_CANNOTWRITE;
                goto ERROR_CANNOT_WRITE;
                }

        // Now ascend out of the fact chunk...
    if ((nError = mmioAscend(*phmmioOut, &ckOut1, 0)) != 0)
                {
        nError = ER_CANNOTWRITE;        // cannot write file, probably
                goto ERROR_CANNOT_WRITE;
                }

         
   
        goto DONE_CREATE;

ERROR_CANNOT_WRITE:
        // Maybe delete the half-written file?  Ah forget it for now, its good to leave the
        // file there for debugging...

DONE_CREATE:
        return(nError);

}

/*      This routine has to be called before any data is written to the wave output file, via wavewritefile.  This
        sets up the data to write, and creates the data chunk.
*/

int WaveStartDataWrite(
                                HMMIO *phmmioOut,                               // (IN)
                                MMCKINFO *pckOut,                               // (IN)
                                MMIOINFO *pmmioinfoOut                  // (OUT)
                                )
{

        int             nError;

        nError = 0;
 /* Create the 'data' chunk that holds the waveform samples.  */
    pckOut->ckid = mmioFOURCC('d', 'a', 't', 'a');
        pckOut->cksize = 0;
    if ((nError = mmioCreateChunk(*phmmioOut, pckOut, 0)) != 0)
                {
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably
                }

        if ((nError = mmioGetInfo(*phmmioOut, pmmioinfoOut, 0)) != 0)
                {
        goto ERROR_CANNOT_WRITE;
        }

        goto CLEANUP;
ERROR_CANNOT_WRITE:     

CLEANUP:
        return(nError);
}

/* This routine will write out data to a wave file. 
        hmmioOut                - Handle to hmmioOut filled by WaveCreateFile
        cbWrite                 - # of bytes to write out.
        pbSrc                   - Pointer to source.
        pckOut                  - pointer to ckOut filled by WaveCreateFile
        cbActualWrite   - # of actual bytes written.
        pmmioinfoOut    - Pointer to mmioinfoOut filled by WaveCreateFile.

        Returns 0 if successful, else the error code.

 */


int WaveWriteFile(
                HMMIO hmmioOut,                         // (IN)
                UINT cbWrite,                           // (IN)
                BYTE *pbSrc,                            // (IN)
                MMCKINFO *pckOut,                       // (IN)
                UINT *cbActualWrite,            // (OUT)
                MMIOINFO *pmmioinfoOut          // (IN)
                )
{
                
        
        int                     nError;
        UINT            cT;

        nError = 0;
        
        *cbActualWrite = 0;

        for (cT=0; cT < cbWrite; cT++)
                {       
                if (pmmioinfoOut->pchNext == pmmioinfoOut->pchEndWrite)
                {
                pmmioinfoOut->dwFlags |= MMIO_DIRTY;
                if ((nError = mmioAdvance(hmmioOut, pmmioinfoOut, MMIO_WRITE)) != 0)
                                {
                    goto ERROR_CANNOT_WRITE;
                                }
                }
                *((BYTE*)pmmioinfoOut->pchNext) = *((BYTE*)pbSrc+cT);
				(*((BYTE*)pmmioinfoOut->pchNext))++;
                (*cbActualWrite)++;
                }
        
        
ERROR_CANNOT_WRITE:
        // What to do here?  Well, for now, nothing, just return that error.  (maybe delete the
        // file later?

        return(nError);

}



/*      This routine will close a wave file used for writing.  Returns 0 if successful, else
        the error code.
        phmmioOut       - Pointer to mmio handle for saving.
        pckOut          - Pointer to the MMCKINFO for saving.
        pckOutRiff      - Pointer to the riff MMCKINFO for saving.
        pmmioinfoOut- Pointer to mmioinfo for saving.
        cSamples        - # of samples saved, for the fact chunk.  For PCM, this isn't used but
                                  will be written anyway, so this can be zero as long as programs ignore
                                  this field when they load PCM formats.



*/
int WaveCloseWriteFile(
                        HMMIO *phmmioOut,               // (IN)
                        MMCKINFO *pckOut,               // (IN)
                        MMCKINFO *pckOutRIFF,   // (IN)
                        MMIOINFO *pmmioinfoOut, // (IN)
                        DWORD cSamples                  // (IN)
                        )
{
                
        int                     nError;                         
                                                                
        nError = 0;

        if (*phmmioOut == NULL)
                return(0);

        pmmioinfoOut->dwFlags |= MMIO_DIRTY;
    if ((nError = mmioSetInfo(*phmmioOut, pmmioinfoOut, 0)) != 0)
                {
                // cannot flush, probably...
        goto ERROR_CANNOT_WRITE;                                
                }

         /* Ascend the output file out of the 'data' chunk -- this will cause
     * the chunk size of the 'data' chunk to be written.
     */
    if ((nError = mmioAscend(*phmmioOut, pckOut, 0)) != 0)
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably


        // Do this here instead...
        if ((nError = mmioAscend(*phmmioOut, pckOutRIFF, 0)) != 0)
        goto ERROR_CANNOT_WRITE;    // cannot write file, probably


        nError = mmioSeek(*phmmioOut, 0, SEEK_SET);
        if ((nError = (int)mmioDescend(*phmmioOut, pckOutRIFF, NULL, 0)) != 0)
                {
                goto ERROR_CANNOT_WRITE;
                }

        nError = 0;
        pckOut->ckid = mmioFOURCC('f', 'a', 'c', 't');
        if ((nError = mmioDescend(*phmmioOut, pckOut, pckOutRIFF, MMIO_FINDCHUNK)) == 0)
                {
                // If it didn't fail, write the fact chunk out, if it failed, not critical, just
                // assert (below).
            nError = mmioWrite(*phmmioOut, (HPSTR)&cSamples, sizeof(DWORD));
                nError = mmioAscend(*phmmioOut, pckOut, 0); 
                nError = 0;
                }
        else 
                {
                nError = 0;
                Assert(FALSE);
                }

// CANTWRITEFACT:
    /* Ascend the output file out of the 'RIFF' chunk -- this will cause
     * the chunk size of the 'RIFF' chunk to be written.
     */