umc_fifo_buf.cpp

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "vm_debug.h"
#include "umc_fifo_buf.h"

UMC::FifoBuffer::~FifoBuffer()
{
    Close();
    assert(NULL == m_pcBuffers);
}

UMC::Status
UMC::FifoBuffer::Init(const vm_var32 uiBufSize, const vm_var32 uiBufNum)
{
    Status umcRes = UMC_OK;

    vm_var32 tmpBuffSize = (uiBufSize + 3) & ~3;
    if (UMC_OK == umcRes) {    umcRes = m_InBufSema.Init(uiBufNum - 2);    }
    if (UMC_OK == umcRes) {    umcRes = m_OutBufSema.Init(0);    }
    if (UMC_OK == umcRes) {    umcRes = m_AccessMut.Init();    }

    if (UMC_OK == umcRes)
    {
        Close();

        //    less then 3 FIFO size does not supported
        assert(3 <= uiBufNum);
        assert(0 < tmpBuffSize);
        assert(NULL == m_pcBuffers);
        m_pcBuffers = new vm_byte[(tmpBuffSize + sizeof(sFrmHdr)) * uiBufNum];

        if (NULL == m_pcBuffers)
        {    umcRes = UMC_ALLOC;    }
#if defined(_DEBUG) || defined(DEBUG)
        else
        {   memset(m_pcBuffers, 0, (tmpBuffSize + sizeof(sFrmHdr)) * uiBufNum);}
#endif // _DEBUG
    }

    if (UMC_OK == umcRes)
    {
        m_uiBufSize = tmpBuffSize + sizeof(sFrmHdr);
        m_uiBufNum = uiBufNum;
    }

    m_uiHead = 0;
    m_uiTail = 0;
    m_uiBufInFifo = 0;

    return umcRes;
}

UMC::Status
UMC::FifoBuffer::GetInBuf(vm_byte** ppucHead)
{
    Status umcRes = UMC_OK;
    if (NULL == m_pcBuffers)
    {    umcRes = UMC_NOT_INITIALIZED;    }
    else if (m_bInBufLocked || UMC_OK != m_InBufSema.TryWait())
    {    umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;    }
    else {
        assert(NULL != ppucHead);
        m_AccessMut.Lock();
        m_bInBufLocked = true;
        *ppucHead =
                m_pcBuffers + m_uiHead * m_uiBufSize + sizeof(sFrmHdr);
        m_AccessMut.Unlock();
#if defined(_DEBUG) || defined(DEBUG)
        memset(*ppucHead, 0, m_uiBufSize - sizeof(sFrmHdr));
#endif // _DEBUG
    }
    assert(UMC_OK != umcRes || NULL != *ppucHead);
    return umcRes;
}

UMC::Status
UMC::FifoBuffer::ReleaseInBuf(vm_var32 uiBufSize, vm_sizet ullIndex)
{
    Status umcRes = UMC_OPERATION_FAILED;
    if (m_bInBufLocked) {
        m_AccessMut.Lock();
        sFrmHdr Hdr;
        Hdr.ullIndex = ullIndex;
        Hdr.uiSize = uiBufSize;
//        vm_var32* uiSizeField =
//                        (vm_var32*)(m_pcBuffers + m_uiHead * m_uiBufSize);
        memcpy(m_pcBuffers + m_uiHead * m_uiBufSize, &Hdr, sizeof(sFrmHdr));
        m_uiBufInFifo++;
        m_uiHead = (m_uiHead + 1) % m_uiBufNum;
        m_bInBufLocked = false;
        umcRes = m_OutBufSema.Signal();
        m_AccessMut.Unlock();
    }
    return umcRes;
}

UMC::Status
UMC::FifoBuffer::GetOutBuf(vm_byte** ppucTail,
                       vm_var32& ruiDataSize,
                       vm_sizet& rullIndex)
{
    Status umcRes = UMC_OK;
    if (NULL == m_pcBuffers)
    {    umcRes = UMC_NOT_INITIALIZED;    }
    else if (m_bOutBufLocked)
    {    umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;    }
    else {
        assert(NULL != ppucTail);
        //    At least 10sec is necessary for start under CE
        //    (debug version, iPAQ h3950)
        umcRes = m_OutBufSema.Wait(10000);
        assert(umcRes != UMC_TIMEOUT);
    }

    if (UMC_OK == umcRes) {
        m_AccessMut.Lock();
        m_bOutBufLocked = true;
        *ppucTail =    m_pcBuffers + m_uiTail * m_uiBufSize;
        assert(NULL != *ppucTail);
        sFrmHdr Hdr;
        memcpy(&Hdr, *ppucTail, sizeof(sFrmHdr));
        ruiDataSize = Hdr.uiSize;
        rullIndex = Hdr.ullIndex;
        *ppucTail += sizeof(sFrmHdr);
        m_AccessMut.Unlock();
    }

    assert(UMC_OK != umcRes || NULL != *ppucTail);
    return umcRes;
}

UMC::Status
UMC::FifoBuffer::ReleaseOutBuf()
{
    Status umcRes = UMC_OPERATION_FAILED;
    if (m_bOutBufLocked) {
        m_AccessMut.Lock();
        m_uiBufInFifo--;
        m_uiTail = (m_uiTail + 1) % m_uiBufNum;
        m_bOutBufLocked = false;
        umcRes = m_InBufSema.Signal();
        m_AccessMut.Unlock();
    }
    return umcRes;
}

void
UMC::FifoBuffer::Close()
{
    if(m_pcBuffers)
    {
        m_AccessMut.Lock();
        delete[] m_pcBuffers;
        m_pcBuffers = NULL;
        m_uiBufSize = 0;
        m_uiBufNum = 0;
        m_uiHead = 0;
        m_uiTail = 0;
        m_uiBufInFifo = 0;
        m_bInBufLocked = false;
        m_bOutBufLocked = false;
        m_AccessMut.Unlock();
    }
}

UMC::Status
UMC::FifoBuffer::Reset()
{
    Status umcRes = UMC_OK;

    m_AccessMut.Lock();

    m_uiHead = 0;
    m_uiTail = 0;
    m_uiBufInFifo = 0;
//    m_bInBufLocked = false;
//    m_bOutBufLocked = false;

    m_AccessMut.Unlock();

    return umcRes;
}