soundbuffer.cpp

<B>人工智能在游戏中的应用的源码</B>

        }

    // Ok, now allocate that waveformatex structure.
    if ((*ppwfxInfo = (WAVEFORMATEX *)GlobalAlloc(GMEM_FIXED, sizeof(WAVEFORMATEX)+cbExtraAlloc)) == NULL)
        {
        nError = ER_MEM;
        goto ERROR_READING_WAVE;
        }

    // Copy the bytes from the pcm structure to the waveformatex structure
    memcpy(*ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat));
    (*ppwfxInfo)->cbSize = cbExtraAlloc;

    // Now, read those extra bytes into the structure, if cbExtraAlloc != 0.
    if (cbExtraAlloc != 0)
        {
        if (mmioRead(hmmioIn, (LPTSTR) (((BYTE*)&((*ppwfxInfo)->cbSize))+sizeof(cbExtraAlloc)),
            (long) (cbExtraAlloc)) != (long) (cbExtraAlloc))
            {
            nError = ER_NOTWAVEFILE;
            goto ERROR_READING_WAVE;
            }
        }

    /* Ascend the input file out of the 'fmt ' chunk. */
    if ((nError = mmioAscend(hmmioIn, &ckIn, 0)) != 0)
        {
        goto ERROR_READING_WAVE;

        }


    goto TEMPCLEANUP;

ERROR_READING_WAVE:
    if (*ppwfxInfo != NULL)
        {
        GlobalFree(*ppwfxInfo);
        *ppwfxInfo = NULL;
        }

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

TEMPCLEANUP:
    *phmmioIn = hmmioIn;

    return(nError);

}

//----------------------------------------------------------------------------------------------
// WaveStartDataRead(): This routine has to be called before WaveReadFile as it searchs for the 
// chunk to descend into for reading, that is, the 'data' chunk.  For simplicity, this used to 
// be in the open routine, but was taken out and moved to a separate routine so there was more 
// control on the chunks that are before the data chunk, such as 'fact', etc...
//----------------------------------------------------------------------------------------------

int CSoundBuffer::WaveStartDataRead(
                    HMMIO *phmmioIn,
                    MMCKINFO *pckIn,
                    MMCKINFO *pckInRIFF
                    )
{
    int                     nError;

    nError = 0;

    // Do a nice little seek...
    if ((nError = mmioSeek(*phmmioIn, pckInRIFF->dwDataOffset + sizeof(FOURCC), SEEK_SET)) == -1)
        {
        _ASSERT(FALSE);
        }

    nError = 0;
    //      Search the input file for for the 'data' chunk.
    pckIn->ckid = mmioFOURCC('d', 'a', 't', 'a');
    if ((nError = mmioDescend(*phmmioIn, pckIn, pckInRIFF, MMIO_FINDCHUNK)) != 0)
        {
        goto ERROR_READING_WAVE;
        }

    goto CLEANUP;

ERROR_READING_WAVE:

CLEANUP:
    return(nError);
}

//----------------------------------------------------------------------------------------------
// WaveFileRad(): This will read wave data from the wave file. Make sure we're descended into
// the data chunk, else this will fail bigtime!
//
//  hmmioIn         - Handle to mmio.
//  cbRead          - # of bytes to read.
//  pbDest          - Destination buffer to put bytes.
//  cbActualRead- # of bytes actually read.
//----------------------------------------------------------------------------------------------

int CSoundBuffer::WaveReadFile(
        HMMIO hmmioIn,                          // IN
        UINT cbRead,                            // IN
        BYTE *pbDest,                           // IN
        MMCKINFO *pckIn,                        // IN.
        UINT *cbActualRead                      // OUT.

        )
{

    MMIOINFO    mmioinfoIn;         // current status of <hmmioIn>
    int                     nError;
    UINT            cT, cbDataIn;

    nError = 0;

    if (nError = mmioGetInfo(hmmioIn, &mmioinfoIn, 0) != 0)
        {
        goto ERROR_CANNOT_READ;
        }

    cbDataIn = cbRead;
    if (cbDataIn > pckIn->cksize)
        cbDataIn = pckIn->cksize;

    pckIn->cksize -= cbDataIn;

    for (cT = 0; cT < cbDataIn; cT++)
        {
        /* Copy the bytes from the io to the buffer. */
        if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead)
            {
        if ((nError = mmioAdvance(hmmioIn, &mmioinfoIn, MMIO_READ)) != 0)
                {
        goto ERROR_CANNOT_READ;
                }
        if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead)
                {
                nError = ER_CORRUPTWAVEFILE;
        goto ERROR_CANNOT_READ;
                }
            }

        // Actual copy. Transform.
        *((BYTE*)pbDest+cT) = *((BYTE*)mmioinfoIn.pchNext);
		mmioinfoIn.pchNext = ((char *)mmioinfoIn.pchNext+1);
        }

    if ((nError = mmioSetInfo(hmmioIn, &mmioinfoIn, 0)) != 0)
        {
        goto ERROR_CANNOT_READ;
        }

    *cbActualRead = cbDataIn;
    goto FINISHED_READING;

ERROR_CANNOT_READ:
    *cbActualRead = 0;

FINISHED_READING:
    return(nError);

}


//----------------------------------------------------------------------------------------------
// WaveCloseReadFile(): This will close the wave file opened with WaveOpenFile.
//    phmmioIn - Pointer to the handle to input MMIO.
//    ppwfxSrc - Pointer to pointer to WaveFormatEx structure.
//
//    Returns 0 if successful, non-zero if there was a warning.
//----------------------------------------------------------------------------------------------

int CSoundBuffer::WaveCloseReadFile(
            HMMIO *phmmio,                          // IN
            WAVEFORMATEX **ppwfxSrc                 // IN
            )
{

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

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

    return(0);

}

//----------------------------------------------------------------------------------------------
// WaveLoadFile(): This routine loads a full wave file into memory. Be careful, wave files can 
// get pretty big these days :).
//
//    szFileName      -       sz Filename
//    cbSize          -       Size of loaded wave (returned)
//    cSamples        -       # of samples loaded.
//    ppwfxInfo       -       Pointer to pointer to waveformatex structure. The wfx structure 
//							  IS ALLOCATED by this routine!  Make sure to free it!
//    ppbData         -       Pointer to a byte pointer (globalalloc) which is allocated by this
//							  routine.  Make sure to free it!
//
//    Returns 0 if successful, else the error code.
//----------------------------------------------------------------------------------------------

int CSoundBuffer::WaveLoadFile(
            TCHAR*pszFileName,                      // (IN)
            UINT *cbSize,                           // (OUT)
            WAVEFORMATEX **ppwfxInfo,				// (OUT)
            BYTE **ppbData                          // (OUT)
            )
{

    HMMIO                           hmmioIn;
    MMCKINFO                        ckInRiff;
    MMCKINFO                        ckIn;
    int                                     nError;
    UINT                            cbActualRead;

    *ppbData = NULL;
    *ppwfxInfo = NULL;
    *cbSize = 0;

    if ((nError = WaveOpenFile(pszFileName, &hmmioIn, ppwfxInfo, &ckInRiff)) != 0)
        {
        goto ERROR_LOADING;
        }

    if ((nError = WaveStartDataRead(&hmmioIn, &ckIn, &ckInRiff)) != 0)
        {
        goto ERROR_LOADING;
        }

    // Ok, size of wave data is in ckIn, allocate that buffer.
    if ((*ppbData = (BYTE *)GlobalAlloc(GMEM_FIXED, ckIn.cksize)) == NULL)
        {
        nError = ER_MEM;
        goto ERROR_LOADING;
        }

    if ((nError = WaveReadFile(hmmioIn, ckIn.cksize, *ppbData, &ckIn, &cbActualRead)) != 0)
        {
        goto ERROR_LOADING;
        }

    *cbSize = cbActualRead;
    goto DONE_LOADING;

ERROR_LOADING:
    if (*ppbData != NULL)
        {
        GlobalFree(*ppbData);
        *ppbData = NULL;
        }
    if (*ppwfxInfo != NULL)
        {
        GlobalFree(*ppwfxInfo);
        *ppwfxInfo = NULL;
        }

DONE_LOADING:
    // Close the wave file.
    if (hmmioIn != NULL)
        {
        mmioClose(hmmioIn, 0);
        hmmioIn = NULL;
        }

    return(nError);

}