umc_mpeg2_video_encoder.cpp

audio-video-codecs.rar语音编解码器

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

#include "umc_defs.h"
#if defined (UMC_ENABLE_MPEG2_VIDEO_ENCODER)

#include "vm_strings.h"
#include "umc_video_data.h"
#include "umc_video_encoder.h"
#include "umc_mpeg2_video_encoder.h"
#include "umc_mpeg2_enc.h"

using namespace UMC;

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

//constructor
MPEG2VideoEncoder::MPEG2VideoEncoder()
{
  vm_debug_trace(VM_DEBUG_INFO, VM_STRING("MPEG2VideoEncoder::MPEG2VideoEncoder"));
  encoder = new MPEG2VideoEncoderBase;
}

//destructor
MPEG2VideoEncoder::~MPEG2VideoEncoder()
{
  vm_debug_trace(VM_DEBUG_INFO, VM_STRING("MPEG2VideoEncoder::~MPEG2VideoEncoder"));
  delete ((MPEG2VideoEncoderBase*)encoder);
}

// Initialize codec with specified parameter(s)
Status MPEG2VideoEncoder::Init(BaseCodecParams *init)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->Init(init);
  return ret;
}

// Compress (decompress) next frame
Status MPEG2VideoEncoder::GetFrame(MediaData *in, MediaData *out)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->GetFrame(in, out);
  return ret;
}

// Compress (decompress) next frame
Status MPEG2VideoEncoderBase::GetFrame(MediaData *in, MediaData *out)
{
  VideoData *vin;
  Ipp32s user_data_size;
  size_t data_size;
  Status ret;
  Ipp64f PTS = -1, DTS = -1;

  if (out == NULL) {
    return UMC_ERR_NULL_PTR;
  }

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

    user_data_size = (Ipp32s)m_UserData.GetDataSize();
    if(user_data_size > 0) {
      setUserData((vm_char*)m_UserData.GetDataPointer(), user_data_size);
    }

    PTS = vin->GetTime();
    if (PTS == 0) {
      PTS = 1e-4;
    }
  }

  LockBuffers();

  data_size = out->GetDataSize();
  if (encodeInfo.lFlags & FLAG_VENC_REORDER) {
    ret = EncodeFrame( vin, out, &PTS, &DTS);
  } else {
    ret = EncodeFrameReordered(vin, out);
  }

  UnlockBuffers();

  if(ret == UMC_OK && m_UserData.GetDataSize() > 0) {
    setUserData(0, 0);
    m_UserData.SetDataSize(0);
  }

  if(data_size == out->GetDataSize() && in == 0)
    return UMC_ERR_NOT_ENOUGH_DATA;

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

  return ret;
}

Status MPEG2VideoEncoder::RepeatLastFrame(Ipp64f PTS, MediaData *out)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->RepeatLastFrame(PTS, out);
  return ret;
}

Status MPEG2VideoEncoderBase::RepeatLastFrame(Ipp64f PTS, MediaData *out)
{
  Status ret;
  Ipp64f DTS = -1;
  Ipp32s i;
  VideoData *frame;

  if (out == NULL) {
    return UMC_ERR_NULL_PTR;
  }

  i = buff_ind + num_new; // index of last frame
  if (i >= buff_size) i -= buff_size;
  frame = VideoData_buff + i;
  ret = EncodeFrame( frame, out, &PTS, &DTS);


  out->SetTime(PTS, DTS);

  return ret;
}

Status MPEG2VideoEncoder::GetNextYUVBuffer(VideoData *data)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->GetNextYUVBuffer(data);
  return ret;
}

Status MPEG2VideoEncoderBase::GetNextYUVBuffer(VideoData *data)
{
  VideoData* next = GetNextYUVPointer();
  if(next == NULL)
    return UMC_ERR_FAILED;
  *data = *next;
  return UMC_OK;
}

// Get codec working (initialization) parameter(s)
Status MPEG2VideoEncoder::GetInfo(BaseCodecParams *info)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->GetInfo(info);
  return ret;
}

// Close all codec resources
Status MPEG2VideoEncoder::Close()
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->Close();
  return ret;
}

Status MPEG2VideoEncoder::Reset()
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->Reset();
  return ret;
}

Status MPEG2VideoEncoderBase::Reset()
{
  return SetParams(0); // it made so
}

Status MPEG2VideoEncoder::SetParams(BaseCodecParams* params)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->SetParams(params);
  return ret;
}

Status MPEG2VideoEncoderBase::SetParams(BaseCodecParams* params)
{
  Status ret;
  ret = Init(params);
  return ret;
}

Status MPEG2VideoEncoder::SetBitRate(Ipp32s BitRate)
{
  Status ret;
  if(encoder == 0)
    return UMC_ERR_NOT_INITIALIZED;
  ret = ((MPEG2VideoEncoderBase*)encoder)->SetBitRate(BitRate);
  vm_debug_trace_s(VM_DEBUG_INFO, "SetBitRate()");
  vm_debug_trace_i(VM_DEBUG_INFO, BitRate);
  return ret;
}

Status MPEG2VideoEncoderBase::SetBitRate(Ipp32s BitRate)
{
  InitRateControl(BitRate);
  return UMC_OK;
}

namespace UMC
{
VideoEncoder* CreateMPEG2Encoder()
{
  VideoEncoder* ptr = new MPEG2VideoEncoder;
  return ptr;
}
}

#endif // UMC_ENABLE_MPEG2_VIDEO_ENCODER