umc_h261_video_encoder.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) 2005 Intel Corporation. All Rights Reserved.
//
*/

#include "vm_debug.h"
#include "vm_time.h"
#include "umc_h261_video_encoder.h"
#include "umc_video_data.h"


namespace UMC
{

H261VideoEncoder::H261VideoEncoder()
{
    m_IsInit = false;
}


H261VideoEncoder::~H261VideoEncoder()
{
    Close();
}


Status H261VideoEncoder::Reset()
{
    return UMC_NOT_IMPLEMENTED;
}


Status H261VideoEncoder::SetParams(BaseCodecParams* params)
{
    return UMC_NOT_IMPLEMENTED;
}


Status H261VideoEncoder::Init(BaseCodecParams* init)
{
    H261EncoderParams *pParam = DynamicCast<H261EncoderParams> (init);

    if (NULL == pParam)
        return UMC_NULL_PTR;
    if (m_IsInit)
        Close();
    m_Param = *pParam;
    int  h261status = h261enc.Init(&pParam->m_Param);
    if (h261status == H261_ERROR_PARAM)
        return UMC_FAILED_TO_INITIALIZE;
    if (h261status == H261_ERROR_NOMEM)
        return UMC_ALLOC;
    m_IsInit = true;
    return UMC_OK;
}


Status H261VideoEncoder::GetInfo(BaseCodecParams* info)
{
    H261EncoderParams* pParam = DynamicCast<H261EncoderParams>(info);

    if (!m_IsInit)
        return UMC_NOT_INITIALIZED;
    if (!pParam)
        return UMC_NULL_PTR;
    *pParam = m_Param;
    return UMC_OK;
}


Status H261VideoEncoder::Close()
{
    if (!m_IsInit)
        return UMC_NOT_INITIALIZED;
    h261enc.Close();
    m_IsInit = false;
    return UMC_OK;
}


Status H261VideoEncoder::GetFrame(MediaData* pIn, MediaData* pOut)
{
    if (!m_IsInit)
        return UMC_NOT_INITIALIZED;
    VideoData* pVideoDataIn = DynamicCast<VideoData> (pIn);
    if (!pOut)
        return UMC_NULL_PTR;
    if (pIn) {
        // init bitstream buffer
        h261enc.cBS.mBitOff = 0;
        h261enc.cBS.mBuffer = (Ipp8u*)pOut->GetDataPointer();
        h261enc.cBS.mBuffSize = pOut->GetBufferSize();
        h261enc.cBS.mPtr = h261enc.cBS.mBuffer;
        // copy YUV to internal frame
        IppiSize roi;
        roi.width = h261enc.mSourceWidth;
        roi.height = h261enc.mSourceHeight;
        ippiCopy_8u_C1R(pVideoDataIn->m_lpDest[0], pVideoDataIn->m_lPitch[0], h261enc.mCurrPtrY, h261enc.mStepLuma, roi);
        roi.width >>= 1;
        roi.height >>= 1;
        ippiCopy_8u_C1R(pVideoDataIn->m_lpDest[1], pVideoDataIn->m_lPitch[1], h261enc.mCurrPtrU, h261enc.mStepChroma, roi);
        ippiCopy_8u_C1R(pVideoDataIn->m_lpDest[2], pVideoDataIn->m_lPitch[2], h261enc.mCurrPtrV, h261enc.mStepChroma, roi);
        h261enc.EncodeFrame();
        pOut->SetDataSize(h261enc.cBS.mPtr - h261enc.cBS.mBuffer);
        pOut->SetTime(pIn->GetTime());
        pIn->SetDataSize(0);
    } else {
        pOut->SetDataSize(0);
        pOut->SetTime(-1.0);
    }
    return UMC_OK;
}


VideoEncoder* createH261VideoEncoder()
{
    H261VideoEncoder* ptr = new H261VideoEncoder;
    return ptr;
}


Status H261EncoderParams::ReadParamFile(const vm_char *FileName)
{
    FILE *InputFile;
    vm_char str[STR_LEN+1];

    InputFile = vm_file_open(FileName, VM_STRING("rt"));
    if (!InputFile) {
        vm_debug_trace(4,__VM_STRING("Error: Couldn't open file '%s'\n"), FileName);
        return UMC_OPERATION_FAILED;
    }
    vm_file_gets(str, STR_LEN, InputFile);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%s"), m_SourceFileName);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.Width);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.Height);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &numFramesToEncode);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantIFrame);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantPFrame);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.IFramedist);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PFramesearchWidth);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PFramesearchHeight);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.MEalgorithm);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.calcPSNR);
    fclose(InputFile);
    m_Param.bsBuffer = (Ipp8u*)1;
    m_Param.bsBuffSize = 1; // encoder will not allocate buffer
    src_width = m_Param.Width;
    src_height = m_Param.Height;
    return UMC_OK;
}


}; //namespace UMC