umc_h263_video_encoder.cpp

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

  m_IsInit = true;
  return UMC_OK;
}

Status H263VideoEncoder::GetInfo(BaseCodecParams* info)
{
  H263EncoderParams* pParam = DynamicCast<H263EncoderParams>(info);
  VideoEncoderParams *VideoParams = DynamicCast<VideoEncoderParams>(info);

  if (!m_IsInit)
      return UMC_ERR_NOT_INITIALIZED;
  if (pParam) {
    *pParam = m_Param;
    VideoParams = pParam;
  } else if (!VideoParams)
    return UMC_ERR_NULL_PTR;

  VideoParams->info.clip_info.width = m_Param.m_Param.Width;
  VideoParams->info.clip_info.height = m_Param.m_Param.Height;
  VideoParams->info.framerate = (Ipp64f)m_Param.m_Param.TimeResolution / m_Param.m_Param.TimeIncrement;

  if (m_Param.m_Param.RateControl)
    VideoParams->info.bitrate = m_Param.m_Param.BitRate;
  else
    VideoParams->info.bitrate = 0;
  //VideoParams->numFramesToEncode = m_Param.m_Param.NumOfFrames;
  VideoParams->numEncodedFrames = m_FrameCount;

  // only 4:3 display aspect ratio is currently supported
  VideoParams->info.aspect_ratio_width = 4;
  VideoParams->info.aspect_ratio_height = 3;
  VideoParams->info.color_format = YUV420;
  VideoParams->info.stream_type = H263_VIDEO;

  return UMC_OK;
}

Status H263VideoEncoder::Close()
{
    if (!m_IsInit)
      return UMC_ERR_NOT_INITIALIZED;
    FreeBuffers();
    // close default memory allocator if exist
    BaseCodec::Close();
    h263enc.Close();
    m_IsInit = false;
    return UMC_OK;
}

Status H263VideoEncoder::GetFrame(MediaData* pIn, MediaData* pOut)
{
  if (!m_IsInit)
    return UMC_ERR_NOT_INITIALIZED;
  VideoData* pVideoDataIn = DynamicCast<VideoData> (pIn);
  if (!pOut)
    return UMC_ERR_NULL_PTR;
  h263enc.InitBuffer((Ipp8u*)pOut->GetDataPointer() + pOut->GetDataSize(),
                      (Ipp8u*)pOut->GetBufferPointer() - (Ipp8u*)pOut->GetDataPointer() + pOut->GetBufferSize() - pOut->GetDataSize());

  LockBuffers();
  if (pVideoDataIn) {
    // copy YUV to internal frame
    IppiSize  roi;
    Ipp8u    *pY, *pU, *pV;
    Ipp32s    stepL, stepC;

    h263enc.GetCurrentFrameInfo(&pY, &pU, &pV, &stepL, &stepC);
    roi.width = m_Param.info.clip_info.width;
    roi.height = m_Param.info.clip_info.height;
    ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(0), pVideoDataIn->GetPlanePitch(0), pY, stepL, roi);
    roi.width >>= 1;
    roi.height >>= 1;
    ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(1), pVideoDataIn->GetPlanePitch(1), pU, stepC, roi);
    ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(2), pVideoDataIn->GetPlanePitch(2), pV, stepC, roi);
  }
  Ipp32s  sts = h263enc.EncodeFrame(pIn == NULL);

  if (sts == H263_STS_ERR_BUFOVER) {
    UnlockBuffers();
    return UMC_ERR_NOT_ENOUGH_BUFFER;
  }
  pOut->SetDataSize(h263enc.GetBufferFullness() + pOut->GetDataSize());
  if (pIn) {
    pIn->SetDataSize(0);
    pOut->SetTime(pIn->GetTime());
  }
  if (sts != H263_STS_NODATA)
    m_FrameCount++;
  UnlockBuffers();
  //return (sts == H263_STS_BUFFERED) ? UMC_ERR_NOT_ENOUGH_DATA : (sts == H263_STS_NODATA) ? UMC_ERR_END_OF_STREAM : UMC_OK;
  return (sts == H263_STS_SKIPPED_FRAME || sts == H263_STS_NODATA) ? UMC_ERR_NOT_ENOUGH_DATA : UMC_OK;
}

VideoEncoder* createH263VideoEncoder()
{
    H263VideoEncoder* ptr = new H263VideoEncoder;
    return ptr;
}

Status H263EncoderParams::ReadParamFile(const vm_char *FileName)
{
    vm_file *InputFile;
    vm_char str[STR_LEN+1];
    Ipp32s rem0, rem1, quot1;
    Ipp64f fdiv1 = 1.0/1001, fquot1;

    InputFile = vm_file_open(FileName, VM_STRING("rt"));
    if (!InputFile) {
        vm_debug_trace1(VM_DEBUG_INFO,VM_STRING("Error: Couldn't open file '%s'\n"), FileName);
        return UMC_ERR_FAILED;
    }
    vm_file_gets(str, STR_LEN, InputFile);
    vm_file_gets(str, STR_LEN, InputFile); //if (SrcFileName) vm_string_sscanf(str, VM_STRING("%s"), SrcFileName);
    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"), &m_Param.NumOfFrames);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.TimeResolution);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.TimeIncrement);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantIPic);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantPPic);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantBPic);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.IPicdist);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PPicdist);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PPicsearchWidth);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PPicsearchHeight);
/*
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BPicsearchWidthForw);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BPicsearchHeightForw);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BPicsearchWidthBack);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BPicsearchHeightBack);
*/
    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.MEaccuracy);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.calcPSNR);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.RateControl);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BitRate);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.SceneChangeThreshold);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.UMV);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.advPred);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.advIntra);
    if (vm_file_gets(str, STR_LEN, InputFile))
      vm_string_sscanf(str, VM_STRING("%d"), &m_Param.GOBheaders);
    if (vm_file_gets(str, STR_LEN, InputFile))
      vm_string_sscanf(str, VM_STRING("%d"), &m_Param.modQuant);
    if (vm_file_gets(str, STR_LEN, InputFile))
      vm_string_sscanf(str, VM_STRING("%d"), &m_Param.FrameSkip);

//    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.deblockFilt);
//    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.data_partitioned);
    vm_file_fclose(InputFile);

    m_Param.bsBuffer = (Ipp8u*)1;
    m_Param.bsBuffSize = 1; // encoder will not allocate buffer

    info.clip_info.width = m_Param.Width;
    info.clip_info.height = m_Param.Height;

    fquot1 = m_Param.TimeIncrement * fdiv1;
    quot1 = (Ipp32s)(fquot1 + 0.5);
    rem1 = m_Param.TimeIncrement - quot1 * 1001;

    if ((rem1 || quot1 > 255) && m_Param.TimeResolution == 30000) {
      m_Param.TimeResolution = 1800000;
      m_Param.TimeIncrement *= 60;
    }
    if (m_Param.TimeResolution != 30000 && m_Param.TimeResolution != 1800000) {
      m_Param.TimeIncrement = (Ipp32s)((Ipp64f)m_Param.TimeIncrement * 1800000 / m_Param.TimeResolution + 0.5);
      rem1 = m_Param.TimeIncrement - (Ipp32s)(m_Param.TimeIncrement * fdiv1 + 0.5) * 1001;
      m_Param.TimeResolution = 1800000;
    }

    rem0 = m_Param.TimeIncrement % 1000;
    if (rem1 && rem0) {
      if (rem1 > 500)
        rem1 = rem1 - 1001;
      if (rem0 > 500)
        rem0 = rem0 - 1000;

      if (h263e_Abs(rem0) < h263e_Abs(rem1)) {
        m_Param.TimeIncrement = m_Param.TimeIncrement - rem0;
      } else {
        m_Param.TimeIncrement = m_Param.TimeIncrement - rem1;
        rem1 = 0;
      }
    } else if (!rem1 && m_Param.TimeResolution == 1800000) {
      Ipp32s q = m_Param.TimeIncrement / 60;
      if (q * 60 == m_Param.TimeIncrement && q <= 255) {
        m_Param.TimeIncrement = q;
        m_Param.TimeResolution = 30000;
      }
    }

    quot1 = (rem1 ? 1000 : 1001);
    if (m_Param.TimeIncrement > 1023 * 127 * quot1)
      m_Param.TimeIncrement = 1023 * 127 * quot1;
    info.framerate = (Ipp64f)m_Param.TimeResolution / m_Param.TimeIncrement;
    if (m_Param.RateControl)
      info.bitrate = m_Param.BitRate;
    else
      info.bitrate = 0;
    //numFramesToEncode = m_Param.NumOfFrames;

    return UMC_OK;
}

}; //namespace UMC