umc_file_writer.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"
#if defined (UMC_ENABLE_FILE_WRITER)

#include <string.h>
#include "umc_file_writer.h"
#include "vm_mmap.h"
#include "vm_debug.h"

UMC::FileWriterParams::FileWriterParams()
{
    m_portion_size = 0;
    memset(m_file_name, 0, sizeof(m_file_name));
}

UMC::FileWriter::FileWriter()
#ifdef USE_FILE_MAPPING
    :m_pbBuffer(NULL),
    m_uiPortionSize(0),
    m_stDoneSize(0),
    m_stPos(0),
    m_uiPageSize(0),
    m_bBufferInit(false)
#endif
{
#ifndef USE_FILE_MAPPING
    m_file = 0;
#else
    vm_mmap_set_invalid(&m_mmap);
#endif
}

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

UMC::Status
UMC::FileWriter::Init(DataWriterParams *pInit)
{
    Status umcRes = UMC_OK;
    FileWriterParams* initFileExt =
                        DynamicCast<FileWriterParams, DataWriterParams>(pInit);
    if(!initFileExt)
        umcRes = UMC_NULL_PTR;

#ifndef USE_FILE_MAPPING
    if (UMC_OK == umcRes) {
        m_file = vm_file_open(initFileExt->m_file_name,__VM_STRING("wb"));
        if (NULL == m_file)
        {   umcRes = UMC_OPERATION_FAILED;  }
    }
#else
    m_uiPageSize = vm_mmap_get_alloc_granularity();

    if (UMC_OK == umcRes) {
        m_uiFileSize = vm_mmap_create(&m_mmap, initFileExt->m_file_name, FLAG_ATTRIBUTE_WRITE);
    }

    if (UMC_OK == umcRes) {
        m_uiPortionSize = m_uiPageSize * 1024;


        vm_sizet csize  = m_uiPortionSize;
        vm_sizet offset = 0;
        m_bBufferInit = false;
        m_pbBuffer = (unsigned char *)vm_mmap_set_view(&m_mmap, &offset, &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);
        }
    }

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

    return umcRes;
}

UMC::Status
UMC::FileWriter::Close()
{
#ifndef USE_FILE_MAPPING
    if(m_file)
        fclose(m_file);

    m_file = 0;
#else
    m_bBufferInit = false;
    vm_mmap_close(&m_mmap);
    m_pbBuffer          = 0;
    m_stPos             = 0;
    m_stDoneSize        = 0;
    m_uiPortionSize     = 0;
#endif

    return UMC_OK;
}

UMC::Status
UMC::FileWriter::Reset()
{
    return UMC_OK;
}

#ifdef USE_FILE_MAPPING

UMC::Status UMC::FileWriter::MapCSize()
{
    vm_sizet tmp_size;

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

    m_stDoneSize += m_uiPageSize*1024;
    m_stPos = 0;

    m_bBufferInit = false;
    tmp_size      = m_uiPageSize*1024;
    if(m_uiFileSize < m_stDoneSize)
        return UMC_FAILED_TO_ALLOCATE_BUFFER;

    m_pbBuffer = (unsigned char *)vm_mmap_set_view(&m_mmap,&m_stDoneSize,&tmp_size);
    if (!m_pbBuffer)
    {
        return UMC_FAILED_TO_ALLOCATE_BUFFER;
    }

    m_bBufferInit = true;
    return UMC_OK;

}
#endif


UMC::Status
UMC::FileWriter::PutData(void *data, int &nsize)
{
#ifndef USE_FILE_MAPPING
    if(m_file && data && (nsize > 0))
        nsize = static_cast<int> (fwrite(data, 1, nsize, m_file));

    return UMC_OK;
#else
    Status  ret     = UMC_OK;
    int     bufsize = 0;
    int     tmp_size = nsize;

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

    while(tmp_size > 0 || ret != UMC_OK)
    {
        if ((m_stPos + tmp_size > m_uiPageSize * 1024) || !m_bBufferInit)
        {
            bufsize     = m_uiPageSize * 1024 - m_stPos;
            memcpy(m_pbBuffer + m_stPos, data, bufsize);
            tmp_size -= bufsize;
            ret = MapCSize();
        }

        if((UMC_OK == ret) && (tmp_size <= m_uiPageSize * 1024))
        {
            memcpy(m_pbBuffer + m_stPos, (unsigned char*)data + bufsize, tmp_size);
            m_stPos += tmp_size;
            break;
        }
    }
    return ret;

#endif

}

#ifndef USE_FILE_MAPPING

UMC::Status
UMC::FileWriter::SetPosition(vm_var32 nPosLow, vm_var32 *lpnPosHight, vm_var32 nMethod)
{
    // check error(s)
    if (NULL == m_file)
        return UMC::UMC_NOT_INITIALIZED;

    // current version isn't support large file(s)
    if ((NULL != lpnPosHight) &&
        (0 != *lpnPosHight))
        return UMC::UMC_UNSUPPORTED;

    // set new position
    if (0 != fseek(m_file, nPosLow, nMethod))
        return UMC::UMC_OPERATION_FAILED;

    return UMC::UMC_OK;

} //UMC::FileWriter::SetPosition(vm_var32 nPosLow, vm_var32 *lpnPosHight, vm_var32 nMethod)


UMC::Status
UMC::FileWriter::GetPosition(vm_var32 *lpnPosLow, vm_var32 *lpnPosHigh)
{
    // check error(s)
    if (NULL == m_file)
        return UMC::UMC_NOT_INITIALIZED;
    if (NULL == lpnPosLow)
        return UMC::UMC_NULL_PTR;

    // return value(s)
    if (lpnPosHigh)
        *lpnPosHigh = 0;
    *lpnPosLow = ftell(m_file);

    return UMC::UMC_OK;

} //UMC::FileWriter::GetPosition(vm_var32 *lpnPosLow, vm_var32 *lpnPosHigh)

#endif //USE_FILE_MAPPING

#endif //(UMC_ENABLE_FILE_WRITER)