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

#include "umc_video_data.h"
#include "umc_video_encoder.h"
#include "umc_mpeg2_video_encoder.h"
#include "mpeg2_video_encoder.h"

namespace UMC
{

static Status errorsIPP2UMC(IppStatus st) {
  if (st == ippStsOk) { // OK
    return UMC_OK;
  } else
  if ((int)st > 0) { // Warning
    return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
  } else {
    switch(st) { // Error
    case ippStsErr: return UMC_OPERATION_FAILED;
    case ippStsNullPtrErr: return UMC_NULL_PTR;
    case ippStsBadArgErr: return UMC_BAD_FORMAT;
    case ippStsMemAllocErr: return UMC_FAILED_TO_ALLOCATE_BUFFER;
    default: return UMC_OPERATION_FAILED;
    }
  }
}

MPEG2EncoderParams::MPEG2EncoderParams() {
  lFlags = FLAG_VENC_REORDER;
}

MPEG2EncoderParams::MPEG2EncoderParams(ippMPEG2EncoderParams *par) {
  lFlags = FLAG_VENC_REORDER;
  *(ippMPEG2EncoderParams*)this = *par;
}

Status MPEG2EncoderParams::ReadParamFile(const vm_char *ParFileName,
                                         vm_char *SrcFileName)
{
  int _Width, _Height, _BitRate, _NumFramesToEncode;
  IppStatus ret;
  ippMPEG2EncoderParams *ippMPEG2Params = (ippMPEG2EncoderParams*)this;
  ret = ippMPEG2Params->ReadParamFile(ParFileName,
    SrcFileName,
    &_Width,
    &_Height,
    &_NumFramesToEncode,
    &_BitRate);
  src_width  = _Width;
  src_height = _Height;
  numFramesToEncode = _NumFramesToEncode;
  BitRate   = _BitRate;
  return errorsIPP2UMC(ret);
}

//////////////////////////////////////////////////////////////////////
// class MPEG2VideoEncoder: public VideoEncoder implementation
// Just calls ippMPEG2VideoEncoder

//constructor
MPEG2VideoEncoder::MPEG2VideoEncoder()
{
  encoder = new ippMPEG2VideoEncoder;
  lFlags = FLAG_VENC_REORDER;
}

//destructor
MPEG2VideoEncoder::~MPEG2VideoEncoder()
{
  delete ((ippMPEG2VideoEncoder*)encoder);
}

// Initialize codec with specified parameter(s)
Status MPEG2VideoEncoder::Init(BaseCodecParams *init)
{
  VideoEncoderParams *VideoParams = DynamicCast<VideoEncoderParams>(init);
  MPEG2EncoderParams *MPEG2Params = DynamicCast<MPEG2EncoderParams>(init);
  ippMPEG2EncoderParams *ippMPEG2Params = NULL;
  IppStatus ret;

  if (NULL != MPEG2Params) {
    ippMPEG2Params = (ippMPEG2EncoderParams*)MPEG2Params;
    lFlags = MPEG2Params->lFlags;
  }
  ret = ((ippMPEG2VideoEncoder*)encoder)->Init(
    VideoParams->src_width,
    VideoParams->src_height,
    VideoParams->BitRate,
    ippMPEG2Params);
  return errorsIPP2UMC(ret);
}

// Compress (decompress) next frame
Status MPEG2VideoEncoder::GetFrame(MediaData *in, MediaData *out)
{
  ippMPEG2VideoEncoder *enc = (ippMPEG2VideoEncoder*)encoder;
  Ipp32s encoded_size;
  VideoData *vin;
  Ipp8u  *_YUV[3];
  Ipp32s _YUV_pitch[3];
  Ipp8u  **YUV = _YUV;
  Ipp32s *YUV_pitch = _YUV_pitch;
  IppStatus ret;

  vin = DynamicCast<VideoData> (in);
  if (in != NULL) {
    if (vin == NULL) {
      return UMC_BAD_FORMAT;
    }

    YUV[0] = vin->m_lpDest[0];
    YUV[1] = vin->m_lpDest[1];
    YUV[2] = vin->m_lpDest[2];
    YUV_pitch[0] = vin->m_lPitch[0];
    YUV_pitch[1] = vin->m_lPitch[1];
    YUV_pitch[2] = vin->m_lPitch[2];
  } else {
    YUV = NULL;
    YUV_pitch = NULL;
  }

  if (lFlags & FLAG_VENC_REORDER) {
    ret = (enc->EncodeFrame)(YUV, YUV_pitch,
      (Ipp8u*)out->GetDataPointer(), out->GetDataSize(), &encoded_size);
  } else {
    ret = (enc->EncodeFrameReordered)(YUV, YUV_pitch, vin->m_FrameType,
      (Ipp8u*)out->GetDataPointer(), out->GetDataSize(), &encoded_size);
  }

  if (vin != NULL) {
    out->SetTime(vin->GetTime());
    vin->SetDataSize(0);
  }

  out->SetDataSize(encoded_size);

  if(encoded_size == 0 && in == 0)
    return UMC_END_OF_STREAM;

  return errorsIPP2UMC(ret);
}

// Get codec working (initialization) parameter(s)
Status MPEG2VideoEncoder::GetInfo(BaseCodecParams *info)
{
  ippMPEG2VideoEncoder *enc = (ippMPEG2VideoEncoder*)encoder;
  VideoEncoderParams *VideoParams = DynamicCast<VideoEncoderParams>(info);
  MPEG2EncoderParams *MPEG2Params = DynamicCast<MPEG2EncoderParams>(info);
  ippMPEG2EncoderParams *ippMPEG2Params = NULL;
  int Width, Height, BitRate;
  IppStatus ret;

  if (NULL == VideoParams) {
    return UMC_NULL_PTR;
  }
  if (NULL != MPEG2Params) {
    ippMPEG2Params = (ippMPEG2EncoderParams*)MPEG2Params;
  }
  ret = enc->GetInfo(
    &Width,
    &Height,
    &VideoParams->FrameRate,
    &BitRate,
    ippMPEG2Params);
  VideoParams->src_width  = Width;
  VideoParams->src_height = Height;
  VideoParams->BitRate   = BitRate;
  return errorsIPP2UMC(ret);
}

// Close all codec resources
Status MPEG2VideoEncoder::Close()
{
  ippMPEG2VideoEncoder *enc = (ippMPEG2VideoEncoder*)encoder;
  IppStatus ret = enc->Close();
  return errorsIPP2UMC(ret);
}

Status MPEG2VideoEncoder::Reset()
{
  return UMC_UNSUPPORTED;
}

Status MPEG2VideoEncoder::SetParams (BaseCodecParams* /*params*/)
{
  return UMC_UNSUPPORTED;
}

VideoEncoder *createMPEG2VideoEncoder()
{
  VideoEncoder* ptr = new MPEG2VideoEncoder;
  return ptr;
}

};//namespace UMC