lockable_data_reader.h

这是在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.
//
*/

#ifndef __LOCKABLE_DATA_READER_H__
#define __LOCKABLE_DATA_READER_H__

#include "umc_mutex.h"
#include "umc_data_reader.h"
//#include <vm_debug.h>

namespace UMC
{
    class LockableDataReaderRef
    {
    public:
        inline LockableDataReaderRef();
        inline LockableDataReaderRef(DataReader* pDataReader,
                                     Mutex* pMutex);
        inline LockableDataReaderRef(const LockableDataReaderRef&);
        inline LockableDataReaderRef& operator=(const LockableDataReaderRef&);
        inline DataReader*  GetRdr();
        inline Status       LockForExclusiveUse();
        inline void         UnlockFromExclusiveUse();
        inline Status       SetPosition(const vm_sizet stNewPos);
        inline vm_sizet     GetPosition();
        inline Status       MovPos(const vm_sizet stIncrement);
    protected:
         DataReader*    m_pDataReader;
         Mutex*         m_pMutex;
         vm_sizet       m_stFilePos;
         bool           m_bLocked;
    }; // class LockableDataReader
} // namespace UMC

UMC::LockableDataReaderRef::LockableDataReaderRef():
    m_pDataReader(NULL),
    m_pMutex(NULL),
    m_stFilePos(0),
    m_bLocked(false)
{}

UMC::LockableDataReaderRef::LockableDataReaderRef(UMC::DataReader* pDataReader,
                                                  UMC::Mutex* pMutex)
{
    assert(NULL != pDataReader);
    assert(NULL != pMutex);
    m_pDataReader = pDataReader;
    m_pMutex = pMutex;
    m_stFilePos = 0;
    m_bLocked = false;
}

UMC::LockableDataReaderRef::LockableDataReaderRef(
                                     const UMC::LockableDataReaderRef& rSrc):
    m_stFilePos(0)
{
    m_pDataReader = rSrc.m_pDataReader;
    m_pMutex = rSrc.m_pMutex;
    m_bLocked = rSrc.m_bLocked;
}

UMC::LockableDataReaderRef&
UMC::LockableDataReaderRef::operator=(const UMC::LockableDataReaderRef& rSrc)
{
    m_pDataReader = rSrc.m_pDataReader;
    m_pMutex = rSrc.m_pMutex;
    m_stFilePos = rSrc.m_stFilePos;
    m_bLocked = rSrc.m_bLocked;
    return *this;
}

UMC::DataReader*
UMC::LockableDataReaderRef::GetRdr()
{
    assert(m_pDataReader);
    return m_pDataReader;
}

UMC::Status
UMC::LockableDataReaderRef::LockForExclusiveUse()
{
    assert(m_pDataReader);
    assert(m_pMutex);
    Status umcRes = UMC_OK;
    vm_debug_trace(0, VM_STRING("LockForExclusiveUse enter\n"));

    if (!m_bLocked)
    {
        m_pMutex->Lock();
        m_bLocked = true;
    }

    umcRes = m_pDataReader->SetPosition(m_stFilePos);

    if (UMC_OK == umcRes)
    {    umcRes = m_pDataReader->StartReadingAfterReposition();    }

    vm_debug_trace(0, VM_STRING("LockForExclusiveUse exit\n"));
    return umcRes;
}

void
UMC::LockableDataReaderRef::UnlockFromExclusiveUse()
{
    assert(m_pDataReader);
    assert(m_pMutex);
    m_stFilePos = m_pDataReader->GetPosition();
    if (m_bLocked)
    {
        m_pMutex->Unlock();
        m_bLocked = false;
    }
    vm_debug_trace(0, VM_STRING("UnlockFromExclusiveUse exit\n"));
}

UMC::Status
UMC::LockableDataReaderRef::SetPosition(const vm_sizet stNewPos)
{
    m_stFilePos = stNewPos;
    return UMC_OK;
}

vm_sizet
UMC::LockableDataReaderRef::GetPosition()
{   return m_stFilePos; }

UMC::Status
UMC::LockableDataReaderRef::MovPos(const vm_sizet stIncrement)
{
    assert(m_pDataReader);
    m_stFilePos += stIncrement;
    if (m_pDataReader->GetSize() <= m_stFilePos)
    {   return UMC_END_OF_STREAM;   }
    else
    {   return UMC_OK;  }
}
#endif // __LOCKABLE_DATA_READER_H__