umc_file_reader.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 "umc_defs.h"

#include "umc_file_reader.h"

#if defined (UMC_ENABLE_FILE_READER) || defined (UMC_ENABLE_FIO_READER)

#include <string.h>
#include "ippdefs.h"
#include "ipps.h"
#include "vm_debug.h"
#include "umc_dynamic_cast.h"

UMC::FileReader::FileReader():
    m_pbBuffer(NULL),
    m_stCurPortionSize(0),
    m_uiPortionSize(0),
    m_stDoneSize(0),
    m_stFileSize(0),
    m_uiPageSize(0),
    m_bBufferInit(false),
    m_bLastPortion(true)
{
        vm_mmap_set_invalid(&m_mmap);
}

UMC::FileReader::~FileReader()
{
    Close();
}

UMC::Status
UMC::FileReader::Init(DataReaderParams *pInit)
{
    UMC::Status umcRes = UMC_OK;

    FileReaderParams* initFileExt = DynamicCast<FileReaderParams, DataReaderParams>(pInit);

    if(!initFileExt)
        return UMC_NULL_PTR;

//    assert(NULL != init->InitExt);
//    sFileRdrInitExt* initFileExt = (sFileRdrInitExt*)init->InitExt;

    m_uiPageSize = vm_mmap_get_alloc_granularity();
    assert(0 != m_uiPageSize);

    if (UMC_OK == umcRes) {
        m_stFileSize = vm_mmap_create(&m_mmap, initFileExt->m_file_name, FLAG_ATTRIBUTE_READ);
        if (0 == m_stFileSize) {
            vm_debug_trace(4, __VM_STRING("File %s open error\n"),
                                                    initFileExt->m_file_name);
            umcRes = UMC_FAILED_TO_OPEN_DEVICE;
        }
    }

    if (UMC_OK == umcRes) {
        if (initFileExt->m_portion_size > 0 &&
            initFileExt->m_portion_size / m_uiPageSize > 0)
        {
            m_uiPortionSize =
                (initFileExt->m_portion_size/m_uiPageSize)*m_uiPageSize;
        } else
        {   m_uiPortionSize = m_uiPageSize * 188;   }


        vm_sizet csize  = m_uiPortionSize;
        m_bLastPortion  = false;
        if (m_stFileSize < csize)
        {   csize = m_stFileSize;   }

        vm_sizet offset = 0;
        m_bBufferInit = false;
        m_pbBuffer = (Ipp8u *)vm_mmap_set_view(&m_mmap, &offset, &csize);
        m_stCurPortionSize  = csize;

        if (!m_pbBuffer) {
            umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
            vm_debug_trace(4, VM_STRING("File %s map error\n"),
                                                    initFileExt->m_file_name);
        } else {
            m_pDataPointer = m_pbBuffer;
            m_pEODPointer  = m_pDataPointer + csize;
        }
    }

    if (UMC_OK == umcRes) {
        m_bBufferInit   = true;
        m_stDoneSize    = 0;
    }
    else
    {   Close();    }

    return umcRes;
}

UMC::Status UMC::FileReader::Close()
{
    m_bBufferInit = false;
    vm_mmap_close(&m_mmap);
    m_pbBuffer          = 0;
    m_pDataPointer      = 0;
    m_pEODPointer       = 0;
    m_stCurPortionSize  = 0;
    m_stDoneSize        = 0;
    m_uiPortionSize     = 0;

    return UMC_OK;
}

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

    if (!vm_mmap_is_valid(&m_mmap)) {   umcRes = UMC_NOT_INITIALIZED;   }

    if(UMC_OK == umcRes && 0 != m_stDoneSize)
    {
        vm_sizet csize, offset;

        m_bBufferInit = false;
        vm_mmap_unmap(&m_mmap);
        m_pbBuffer = 0;

        csize =
            (m_stFileSize < m_uiPortionSize) ? m_stFileSize : m_uiPortionSize;
        offset = 0;
        m_pbBuffer = (Ipp8u *)vm_mmap_set_view(&m_mmap, &offset, &csize);
        m_stCurPortionSize  = m_uiPortionSize;

        if (!m_pbBuffer)
            umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
        else {
            m_bBufferInit = true;
            m_pDataPointer = m_pbBuffer;
            m_pEODPointer  = m_pDataPointer + csize;
        }
    }
    m_stDoneSize    = 0;

    return umcRes;
}


UMC::Status UMC::FileReader::MapCSize(vm_sizet csize)
{
    vm_sizet tmp_size;
    vm_var32 stPos = m_pDataPointer - m_pbBuffer;

    if (!vm_mmap_is_valid(&m_mmap)) {   return UMC_NOT_INITIALIZED;   }

    if(m_stDoneSize + m_stCurPortionSize >= m_stFileSize)
        return UMC_END_OF_STREAM;
    tmp_size = (m_stDoneSize + stPos) % m_uiPageSize;
    m_stDoneSize = (m_stDoneSize + stPos) - tmp_size;
    if(m_bLastPortion)
        return UMC_END_OF_STREAM;
    if(m_stDoneSize + m_uiPortionSize >= m_stFileSize)
    {
        m_stCurPortionSize  = m_stFileSize - m_stDoneSize;
        m_bLastPortion      = true;
    }
    else
        m_stCurPortionSize  = m_uiPortionSize;
    m_bBufferInit = false;
    m_pbBuffer = (Ipp8u *)vm_mmap_set_view(&m_mmap,&m_stDoneSize,&m_stCurPortionSize);
    if (!m_pbBuffer)
    {
        if(m_stDoneSize + csize> m_stFileSize)
            return UMC_END_OF_STREAM;
        else
            return UMC_FAILED_TO_ALLOCATE_BUFFER;
    } else {
        m_pDataPointer = m_pbBuffer + tmp_size;
        m_pEODPointer  = m_pbBuffer + m_stCurPortionSize;
    }

    m_bBufferInit = true;

    return UMC_OK;

}

UMC::Status UMC::FileReader::ReadData(void *data, vm_var32 *nsize)
{
    UMC::Status  ret = UMC_OK;
    vm_var32 tmp_size = 0;
    vm_var32 stPos = m_pDataPointer - m_pbBuffer;

    if(m_isRepositionHappend)
    {
        return UMC_WAIT_FOR_REPOSITION;
    }

    if (!vm_mmap_is_valid(&m_mmap)) {   return UMC_NOT_INITIALIZED;   }

    if ((stPos + *nsize > m_stCurPortionSize || !m_bBufferInit))
    {
        tmp_size = (vm_var32)(m_stFileSize - m_stDoneSize - (stPos));
        if(tmp_size < *nsize && tmp_size != 0)
        {
            memcpy(data, m_pDataPointer, tmp_size);
            m_pDataPointer += tmp_size;
            m_bLastPortion = true;
            ret = UMC_END_OF_STREAM;
        }
        else
        {   ret = MapCSize(*nsize); stPos = m_pDataPointer - m_pbBuffer; }
    }

    if (UMC_OK == ret) {
        unsigned long get_size = *nsize;
        if(stPos + *nsize > m_stCurPortionSize)
        {
            get_size = static_cast<unsigned long>(m_stCurPortionSize - (stPos));
        }
        memcpy(data, m_pDataPointer, get_size);
        m_pDataPointer += get_size;
        *nsize = get_size;
    }
    else
    {
        *nsize = tmp_size;
    }

    return ret;
}

UMC::Status UMC::FileReader::CacheData(void *data, vm_var32 *nsize, int how_far)
{
    UMC::Status  ret = UMC_OK;
    vm_var32     stPos = m_pDataPointer - m_pbBuffer;

    if(m_isRepositionHappend)
    {
        return UMC_WAIT_FOR_REPOSITION;
    }

    if (!vm_mmap_is_valid(&m_mmap)) {   ret = UMC_NOT_INITIALIZED;   }

    if (UMC_OK == ret &&
        (stPos + how_far + *nsize > m_stCurPortionSize || !m_bBufferInit))
    {   ret = MapCSize(*nsize); }

    if (UMC_OK == ret)
    {   memcpy(data, m_pDataPointer + how_far, *nsize);   }

    return ret;
}

UMC::Status UMC::FileReader::MovePosition(vm_sizet npos)
{
    UMC::Status  ret = UMC_OK;
    vm_var32     stPos = m_pDataPointer - m_pbBuffer;

    if(m_isRepositionHappend)
    {
        return UMC_WAIT_FOR_REPOSITION;
    }
    if (!vm_mmap_is_valid(&m_mmap)) {   ret = UMC_NOT_INITIALIZED;   }

    if (UMC_OK == ret) {
        if( (stPos + npos <= m_stCurPortionSize) || npos <= 0 || !m_bBufferInit)
        {   m_pDataPointer += npos; }
        else
        {
            ret = MapCSize(npos);
            if (UMC_OK == ret) {
            m_pDataPointer += npos;
            if ((m_pEODPointer - m_pbBuffer) < (m_pDataPointer - m_pbBuffer))
              m_pEODPointer = m_pDataPointer;
            }
        }
    }
    return ret;
}

vm_sizet UMC::FileReader::GetPosition()
{
    vm_var32     stPos = m_pDataPointer - m_pbBuffer;

    return (m_stDoneSize + stPos);
}

UMC::Status UMC::FileReader::SetPosition(double position)
{
    UMC::Status     ret = UMC_OK;
    vm_var32      stPos = m_pDataPointer - m_pbBuffer;

    m_isRepositionHappend = true;
    m_bLastPortion  = false;

    vm_sizet        new_pos = (vm_sizet)(position * (double)(vm_var64s)m_stFileSize + 0.5);
    unsigned int    new_portion = (vm_var32)(new_pos/m_uiPortionSize + 1);
    unsigned int    cur_portion    = (vm_var32)((m_stDoneSize + stPos)/m_uiPortionSize + 1);
    //if(new_portion != portion ){

    if (!vm_mmap_is_valid(&m_mmap)) {   ret = UMC_NOT_INITIALIZED;   }

    if(new_portion != cur_portion)
    {
        m_pDataPointer = m_pbBuffer;
        m_stCurPortionSize = 0;
        m_stDoneSize = (vm_sizet)(new_portion - 1) * m_uiPortionSize;
        ret = MapCSize(0);
    }
    else
    {
        m_stDoneSize = (vm_sizet)(new_portion - 1) * m_uiPortionSize;
    }

    if(ret == UMC_OK)
        m_pDataPointer = m_pbBuffer + (new_pos-m_stDoneSize);
    return ret;
}

vm_sizet UMC::FileReader::GetSize()
{
    return m_stFileSize;
}
#endif // (UMC_ENABLE_FILE_READER)