DWORD dwFileSizeHigh = 0;
        DWORD dwFileSize = GetFileSize( hFile, &dwFileSizeHigh );
        CloseHandle( hFile );
        if( dwFileSizeHigh != 0 || dwFileSize > 1000000 )
        {
            SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("File too large.  You should stream large files.") );
            return E_FAIL;
        }
    }
    
    if( FAILED( hr = waveFile.Open( strFileName, NULL, WAVEFILE_READ ) ) )
    {
        waveFile.Close();
        SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Bad wave file.") );
        return DXTRACE_ERR_MSGBOX( TEXT("Open"), hr );
    }
    else 
    {
        WAVEFORMATEX* pwfx = waveFile.GetFormat();
        if( pwfx->wFormatTag != WAVE_FORMAT_PCM && pwfx->wFormatTag != WAVE_FORMAT_IEEE_FLOAT )
        {
            
            SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Wave file must be PCM or IEEE FLOAT for effects control.") );
            SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
            return E_FAIL;
        }
        
        waveFile.Close();
        
        SetDlgItemText( hDlg, IDC_TEXT_FILENAME, strFileName );
        SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("File loaded.") );
        strcpy( g_tszFilename, strFileName );
        return S_OK;
    }
}
CSoundFXManager::CSoundFXManager( )
{
    m_lpChorus = NULL;
    m_lpCompressor = NULL;
    m_lpDistortion = NULL;
    m_lpEcho = NULL;
    m_lpFlanger = NULL;
    m_lpGargle = NULL;
    m_lpParamEq = NULL;
    m_lpReverb = NULL;
    ZeroMemory( &m_paramsChorus, sizeof( DSFXChorus ) );
    ZeroMemory( &m_paramsCompressor, sizeof( DSFXCompressor ) );
    ZeroMemory( &m_paramsDistortion, sizeof( DSFXDistortion ) );
    ZeroMemory( &m_paramsFlanger, sizeof( DSFXFlanger ) );
    ZeroMemory( &m_paramsEcho, sizeof( DSFXEcho ) );
    ZeroMemory( &m_paramsGargle, sizeof( DSFXGargle ) );
    ZeroMemory( &m_paramsParamEq, sizeof( DSFXParamEq ) );
    ZeroMemory( &m_paramsReverb, sizeof( DSFXWavesReverb ) );
    m_dwNumFX = 0;
    ZeroMemory( m_rgFxDesc, sizeof( DSEFFECTDESC ) * eNUM_SFX );
    ZeroMemory( m_rgRefGuids, sizeof( GUID * ) * eNUM_SFX );
    ZeroMemory( m_rgPtrs, sizeof(LPVOID*) * eNUM_SFX );
    ZeroMemory( m_rgLoaded, sizeof( BOOL ) * eNUM_SFX );
    m_lpDSB8 = NULL;
}
CSoundFXManager::~CSoundFXManager( )
{
    
    DisableAllFX( );
    
    SAFE_RELEASE( m_lpDSB8 );
}
HRESULT CSoundFXManager::Initialize( LPDIRECTSOUNDBUFFER lpDSB, BOOL bLoadDefaultParamValues )
{
    HRESULT hr;
    if( m_lpDSB8 )
    {
        
        DisableAllFX( );
        SAFE_RELEASE( m_lpDSB8 );
    }
    if( NULL == lpDSB )
        return S_OK;
    
    if( FAILED( hr = lpDSB->QueryInterface( IID_IDirectSoundBuffer8, (LPVOID*) &m_lpDSB8 ) ) )
        return hr;
    if( bLoadDefaultParamValues )
        LoadDefaultParamValues( );
    return S_OK;
}
HRESULT CSoundFXManager::UnInitialize( )
{
    Initialize( NULL, FALSE );
    return S_OK;
}
HRESULT CSoundFXManager::LoadDefaultParamValues( )
{
    DWORD i;
    if( NULL == m_lpDSB8 )
        return E_FAIL;
    for( i = eSFX_chorus; i < eNUM_SFX; i++ )
        SetFXEnable( i );
    ActivateFX( );
    if( m_lpChorus )
        m_lpChorus->GetAllParameters( &m_paramsChorus );
    if( m_lpCompressor )
        m_lpCompressor->GetAllParameters( &m_paramsCompressor );
    if( m_lpDistortion )
        m_lpDistortion->GetAllParameters( &m_paramsDistortion );
    if( m_lpEcho )
        m_lpEcho->GetAllParameters( &m_paramsEcho );
    if( m_lpFlanger )
        m_lpFlanger->GetAllParameters( &m_paramsFlanger );
    if( m_lpGargle )
        m_lpGargle->GetAllParameters( &m_paramsGargle );
    if( m_lpParamEq )
        m_lpParamEq->GetAllParameters( &m_paramsParamEq );
    if( m_lpReverb )
        m_lpReverb->GetAllParameters( &m_paramsReverb );
    DisableAllFX( );
    return S_OK;
}
HRESULT CSoundFXManager::LoadCurrentFXParameters( )
{
    if( m_lpChorus )
        m_lpChorus->SetAllParameters( &m_paramsChorus );
    if( m_lpCompressor )
        m_lpCompressor->SetAllParameters( &m_paramsCompressor );
    if( m_lpDistortion )
        m_lpDistortion->SetAllParameters( &m_paramsDistortion );
    if( m_lpEcho )
        m_lpEcho->SetAllParameters( &m_paramsEcho );
    if( m_lpFlanger )
        m_lpFlanger->SetAllParameters( &m_paramsFlanger );
    if( m_lpGargle )
        m_lpGargle->SetAllParameters( &m_paramsGargle );
    if( m_lpParamEq )
        m_lpParamEq->SetAllParameters( &m_paramsParamEq );
    if( m_lpReverb )
        m_lpReverb->SetAllParameters( &m_paramsReverb );
    return S_OK;
}
HRESULT CSoundFXManager::
SetFXEnable( DWORD esfxType )
{
    HRESULT hr;
    if( esfxType >= eNUM_SFX )
        return E_FAIL;
    if( m_rgLoaded[esfxType] )
        return S_FALSE;
    else
        m_rgLoaded[esfxType] = TRUE;
    switch ( esfxType )
    {
    case eSFX_chorus:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_CHORUS,     IID_IDirectSoundFXChorus8,
                              (LPVOID*) &m_lpChorus );
        break;
    case eSFX_compressor:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_COMPRESSOR, IID_IDirectSoundFXCompressor8,
                              (LPVOID*) &m_lpCompressor );
        break;
    case eSFX_distortion:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_DISTORTION, IID_IDirectSoundFXDistortion8,
                              (LPVOID*) &m_lpDistortion );
        break;
    case eSFX_echo:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_ECHO,       IID_IDirectSoundFXEcho8,
                              (LPVOID*) &m_lpEcho );
        break;
    case eSFX_flanger:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_FLANGER,    IID_IDirectSoundFXFlanger8,
                              (LPVOID*) &m_lpFlanger );
        break;
    case eSFX_gargle:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_GARGLE,     IID_IDirectSoundFXGargle8,
                              (LPVOID*) &m_lpGargle );
        break;
    case eSFX_parameq:
        hr = EnableGenericFX( GUID_DSFX_STANDARD_PARAMEQ,    IID_IDirectSoundFXParamEq8,
                              (LPVOID*) &m_lpParamEq );
        break;
    case eSFX_reverb:
        hr = EnableGenericFX( GUID_DSFX_WAVES_REVERB,        IID_IDirectSoundFXWavesReverb8,
                              (LPVOID*) &m_lpReverb );
        break;
    default:
        hr = E_FAIL;
        break;
    }
    return hr;
}
HRESULT CSoundFXManager::DisableAllFX( )
{
    
    SAFE_RELEASE( m_lpChorus );
    SAFE_RELEASE( m_lpCompressor );
    SAFE_RELEASE( m_lpDistortion );
    SAFE_RELEASE( m_lpEcho );
    SAFE_RELEASE( m_lpFlanger );
    SAFE_RELEASE( m_lpGargle );
    SAFE_RELEASE( m_lpParamEq );
    SAFE_RELEASE( m_lpReverb );
    m_dwNumFX = 0;
    ZeroMemory( m_rgFxDesc, sizeof( DSEFFECTDESC ) * eNUM_SFX );
    ZeroMemory( m_rgRefGuids, sizeof( GUID * ) * eNUM_SFX );
    ZeroMemory( m_rgPtrs, sizeof(LPVOID*) * eNUM_SFX );
    ZeroMemory( m_rgLoaded, sizeof( BOOL ) * eNUM_SFX );
    if( NULL == m_lpDSB8 )
        return E_FAIL;
    
    if( m_lpDSB8 )
        m_lpDSB8->Stop();
    
    m_lpDSB8->SetFX( 0, NULL, NULL );
    return S_OK;
}
HRESULT CSoundFXManager::ActivateFX( )
{
    DWORD dwResults[eNUM_SFX];
    HRESULT hr;
    DWORD i;
    if( NULL == m_lpDSB8 )
        return E_FAIL;
    if( m_dwNumFX == 0 )
        return S_FALSE;
    if( FAILED( hr = m_lpDSB8->SetFX( m_dwNumFX, m_rgFxDesc, dwResults ) ) )
        return hr;
    
    for( i = 0; i < m_dwNumFX; i++ )
        if( FAILED( hr = m_lpDSB8->GetObjectInPath( m_rgFxDesc[i].guidDSFXClass, 0, *m_rgRefGuids[i], m_rgPtrs[i] ) ) )
            return DXTRACE_ERR_MSGBOX( TEXT("GetObjectInPath"), hr );
    return S_OK;
}
HRESULT CSoundFXManager::EnableGenericFX( GUID guidSFXClass, REFGUID rguidInterface, LPVOID * ppObj )
{
    
    if( *ppObj )
        return S_FALSE;
    if( m_dwNumFX >= eNUM_SFX )
        return E_FAIL;
    
    ZeroMemory( &m_rgFxDesc[m_dwNumFX], sizeof(DSEFFECTDESC) );
    m_rgFxDesc[m_dwNumFX].dwSize         = sizeof(DSEFFECTDESC);
    m_rgFxDesc[m_dwNumFX].dwFlags        = 0;
    CopyMemory( &m_rgFxDesc[m_dwNumFX].guidDSFXClass, &guidSFXClass, sizeof(GUID) );
    m_rgRefGuids[m_dwNumFX] = &rguidInterface;
    m_rgPtrs[m_dwNumFX] = ppObj;
    m_dwNumFX++;
    return S_OK;
}