dsound_buf.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

            {
                umcRes = UMC_OPERATION_FAILED;
            }
        }
        else
        {
            if (FAILED(m_pDSBSecondary->Play( 0, 0, DSBPLAY_LOOPING)))
            {
                umcRes = UMC_OPERATION_FAILED;
            }
        }
    }

    m_MutAccess.Unlock();

    return umcRes;
}

float
UMC::DSBuffer::SetVolume(float fVolume)
{
    if (!m_pDSBSecondary)
    {
        return 0;
    }
    m_MutAccess.Lock();
    LONG previous_volume;
    m_pDSBSecondary->GetVolume(&previous_volume);
    fVolume = min(1,max(0,fVolume));
    HRESULT dr=m_pDSBSecondary->SetVolume((LONG)(fVolume*(DSBVOLUME_MAX-DSBVOLUME_MIN)+DSBVOLUME_MIN));
    switch (dr) {
    case DSERR_CONTROLUNAVAIL:
        dr=1;
        break;
    case DSERR_GENERIC:
        dr=1;
        break;
    case DSERR_INVALIDPARAM:
        dr=1;
        break;
    case DSERR_PRIOLEVELNEEDED:
        dr=1;
        break;
    }
    m_MutAccess.Unlock();

    return (float)(previous_volume-DSBVOLUME_MIN)/(DSBVOLUME_MAX-DSBVOLUME_MIN);
}

float
UMC::DSBuffer::GetVolume()
{
    LONG previous_volume;
    if (!m_pDSBSecondary)
    {
        return 0;
    }
    m_MutAccess.Lock();
    m_pDSBSecondary->GetVolume(&previous_volume);
    m_MutAccess.Unlock();

    return (float)(previous_volume-DSBVOLUME_MIN)/(DSBVOLUME_MAX-DSBVOLUME_MIN);
}

UMC::Status
UMC::DSBuffer::Reset()
{
     if (!m_pDSBSecondary)
    {
        return UMC_OPERATION_FAILED;
    }
    m_MutAccess.Lock();
    Status umcRes = (m_pDSBSecondary) ? UMC_OK : UMC_NOT_INITIALIZED;

    if (UMC_OK == umcRes) {    umcRes = Pause(true);    }

    void *lock1_ptr = NULL;
    void *lock2_ptr = NULL;
    DWORD lock1_bytes = 0;
    DWORD lock2_bytes = 0;

    if (UMC_OK == umcRes) {
        if (FAILED(m_pDSBSecondary->Lock(0, m_dwDSBufferSize,
                                        &lock1_ptr, &lock1_bytes,
                                        &lock2_ptr, &lock2_bytes,
                                        DSBLOCK_ENTIREBUFFER)))
        {
            vm_debug_msg( 0xffffffff, VM_STRING("Failed to lock DirectSound secondary buffer @Open"));
            umcRes = UMC_OPERATION_FAILED;
        }
    }

    if (UMC_OK == umcRes) {
        ippsZero_8u((Ipp8u*)lock1_ptr,lock1_bytes);
        m_pDSBSecondary->Unlock(lock1_ptr, lock1_bytes, lock2_ptr, 0);
        m_bPausedWaitingData = true;
        m_pDSBSecondary->SetCurrentPosition(0);
        m_dwNextWriteOffset = 0;
    }
    m_MutAccess.Unlock();

    return umcRes;
}

void
UMC::DSBuffer::Close()
{
    if (!m_pDSBSecondary)
    {
        return;
    }
    m_MutAccess.Lock();
    if (m_pDSBPrimary)
        m_pDSBPrimary->Play(0,0,DSBPLAY_LOOPING);

    if (m_pDSBSecondary) {
        Pause(true);
        m_pDSBSecondary->Release();
        m_pDSBSecondary = NULL;
    }

    if( m_pDSBPrimary ) {
        m_pDSBPrimary->Release();
        m_pDSBPrimary = NULL;
    }

    if (m_pDS) {
        m_pDS->Release();
        m_pDS = NULL;
    }
    m_dwDSBufferSize = 0;
    m_dwNextWriteOffset = 0;
    m_dfNorm = 1;
    m_dfCompensation = 0;
    m_hWnd = NULL;
    m_bPausedWaitingData = false;

    m_MutAccess.Unlock();

}

UMC::Status UMC::DSBuffer::DynamicSetParams(const WORD wChannels,
                            const DWORD dwFrequency,
                            const WORD wBytesPerSample)
{
    UMC::Status umcRes = UMC::UMC_OK;
    WAVEFORMATEX wfx;
    ippsZero_8u( (Ipp8u*)&wfx, sizeof(WAVEFORMATEX) );

    m_pDSBPrimary->GetFormat(&wfx, sizeof(WAVEFORMATEX), NULL);
    Pause(true);

    if((wfx.nChannels == wChannels) && (dwFrequency != wfx.nSamplesPerSec))
    {
        if( FAILED(m_pDSBSecondary->SetFrequency(dwFrequency) ) )
        {
            vm_debug_msg(0, VM_STRING("Failed to set Frequency for DirectSound buffer @DynamicSetParams"));
            umcRes = UMC_FAILED_TO_OPEN_DEVICE;
        }
        m_dfNorm = 1.0/dwFrequency/m_wInitedBytesPerSample/wChannels;

    }
    else
    {
        /*wfx.wFormatTag      = WAVE_FORMAT_PCM;
        wfx.nChannels       = wChannels;
        wfx.nSamplesPerSec  = dwFrequency;
        wfx.wBitsPerSample  = (WORD)(wBytesPerSample << 3);
        wfx.nBlockAlign     = (WORD) (wfx.wBitsPerSample / 8 * wfx.nChannels);
        wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
        if( FAILED(m_pDSBPrimary->SetFormat(&wfx) ) )
        {
            vm_debug_msg(0, VM_STRING("Failed to set format for DirectSound buffer @DynamicSetParams"));
            umcRes = UMC_FAILED_TO_OPEN_DEVICE;
        }  */

        {
            m_MutAccess.Lock();
            /*if (m_pDSBPrimary)
                m_pDSBPrimary->Play(0,0,DSBPLAY_LOOPING);
*/
            if (m_pDSBSecondary) {
                m_pDSBSecondary->Release();
                m_pDSBSecondary = NULL;
            }

            /*if( m_pDSBPrimary ) {
                m_pDSBPrimary->Release();
                m_pDSBPrimary = NULL;
            }*/

            DSBUFFERDESC dsbd;
            // Get the primary buffer
            /*if(UMC_OK == umcRes)
            {
                ippsZero_8u( (Ipp8u*)&dsbd, sizeof(DSBUFFERDESC) );
                dsbd.dwSize        = sizeof(DSBUFFERDESC);
                dsbd.dwFlags       = DSBCAPS_PRIMARYBUFFER;
                dsbd.dwBufferBytes = 0;
                dsbd.lpwfxFormat   = NULL;

                if( FAILED(m_pDS->CreateSoundBuffer( &dsbd, &m_pDSBPrimary, NULL ) ) )
                {
                    vm_debug_msg( -1, VM_STRING("Failed to create DirectSound primary buffer @Open"));
                    umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
                }
            }*/

            //    Set primary buffer format
            WAVEFORMATEX wfx;
            if(UMC_OK == umcRes)
            {
                ippsZero_8u( (Ipp8u*)&wfx, sizeof(WAVEFORMATEX) );
                wfx.wFormatTag      = WAVE_FORMAT_PCM;
                wfx.nChannels       = wChannels;
                wfx.nSamplesPerSec  = dwFrequency;
                wfx.wBitsPerSample  = (WORD)(m_wInitedBytesPerSample << 3);
                wfx.nBlockAlign     = (WORD) (wfx.wBitsPerSample / 8 * wfx.nChannels);
                wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;

                if( FAILED(m_pDSBPrimary->SetFormat(&wfx) ) )
                {
                    vm_debug_msg(-1, VM_STRING("Failed to set PCM format for DirectSound primary buffer @Open"));
                    umcRes = UMC_FAILED_TO_OPEN_DEVICE;
                }

            }

            //    Create Secondary buffer
            if(UMC_OK == umcRes)
            {
                ippsZero_8u( (Ipp8u*)&dsbd, sizeof(DSBUFFERDESC) );
                dsbd.dwSize        = sizeof(DSBUFFERDESC);
                dsbd.dwFlags       = DSBCAPS_STICKYFOCUS|DSBCAPS_CTRLVOLUME|
                                    DSBCAPS_CTRLFREQUENCY|DSBCAPS_GETCURRENTPOSITION2;
                dsbd.dwBufferBytes = m_dwInitedBufferSize;
                dsbd.lpwfxFormat   = &wfx;

                if( FAILED(m_pDS->CreateSoundBuffer( &dsbd, &m_pDSBSecondary, NULL )))
                {
                    vm_debug_msg(-1, VM_STRING("Failed to create DirectSound secondary buffer @Open"));
                    umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
                }
            }

            /*if(UMC_OK == umcRes)
            {
                void *lock1_ptr, *lock2_ptr;
                DWORD lock1_bytes, lock2_bytes;
                if (FAILED(m_pDSBSecondary->Lock(0,m_dwDSBufferSize,
                                                    &lock1_ptr,&lock1_bytes,
                                                    &lock2_ptr,&lock2_bytes,
                                                    DSBLOCK_ENTIREBUFFER)))
                {
                    vm_debug_msg(-1, VM_STRING("Failed to lock DirectSound secondary buffer @Open"));
                    umcRes = UMC_FAILED_TO_OPEN_DEVICE;
                }
                else
                {
                    ippsZero_8u((Ipp8u*)lock1_ptr,lock1_bytes);
                    m_pDSBSecondary->Unlock(lock1_ptr,lock1_bytes,lock2_ptr,0);
                }
            }  */
            m_dfNorm = 1.0/dwFrequency/m_wInitedBytesPerSample/wChannels;
            m_MutAccess.Unlock();
        }
    }

    Pause(false);
    return umcRes;
}
#endif    // UMC_ENABLE_DSOUND_AUDIO_RENDER