umc_vc1_enc_adv.cpp

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

            inputPictureType = VC1_ENC_I_FRAME;
            break;
        case UMC::P_PICTURE:
            inputPictureType = VC1_ENC_P_FRAME;
            break;
        case UMC::B_PICTURE:
            inputPictureType = VC1_ENC_B_FRAME;
            break;
        default:
            inputPictureType = m_pGOP->GetPictureType(m_iFrameCount,m_uiGOPLength,m_uiBFrmLength);
            break;
        };
        m_iFrameCount++;

        in_frame = m_pStoredFrames->GetFreeFramePointer();
        if (in_frame)
        {
            in_frame->CopyPlane( (Ipp8u*)pVideoData->GetPlanePointer(0), (Ipp32u)pVideoData->GetPlanePitch(0),
                                 (Ipp8u*)pVideoData->GetPlanePointer(1), (Ipp32u)pVideoData->GetPlanePitch(1),
                                 (Ipp8u*)pVideoData->GetPlanePointer(2), (Ipp32u)pVideoData->GetPlanePitch(2),
                                 inputPictureType);

            if (!m_pWaitingList->AddFrame(in_frame))
                return UMC::UMC_ERR_NOT_ENOUGH_BUFFER;
            pVideoData->SetDataSize(0);
            stored = true;
        }
    }

    while ((frame = m_pWaitingList->GetCurrFrame())!=0)
    {
        if (!m_pGOP->AddFrame(frame))
            break;
            m_pWaitingList->MoveOnNextFrame();
    }

    /*------------------------------------------------------------------------------------------------------------*/

    if (!pVideoData)
    {
        m_pGOP->CloseGop();
    }

    frame = m_pGOP->GetFrameForDecoding();

    if (frame)
    {
        while(frame_recoding && (RecodedFrameNum < VC1_ENC_RECODING_MAX_NUM))
        {
            Frame* pFrameRef = 0;
            m_CodedFrame->Init(out);
            if (!m_bSequenceHeader)
            {
                err = m_SH->WriteSeqHeader(m_CodedFrame);
                if (err != UMC::UMC_OK)
                    return err;

                m_bSequenceHeader = true;
            }

            err = m_pCurrPicture->Init(m_SH,m_pMBs,m_pCodedMB);
            if (err != UMC::UMC_OK)
                return err;

            //----------motion estimation------------
            m_pCurrPicture->SetMEParams(m_pME, m_MESearchSpeed);

            // only for advance profile
            err = frame->PadPlaneProgressive();
            if (err != UMC::UMC_OK)
                return err;
            err = m_pCurrPicture->SetPlaneParams (  frame,VC1_ENC_CURR_PLANE);
            if (err != UMC::UMC_OK)
                return err;
            if (frame->GetPictureType()!= VC1_ENC_B_FRAME && m_uiGOPLength>1)
            {

                err = m_pCurrPicture->SetPlaneParams  ( frame, VC1_ENC_RAISED_PLANE);
                if (err != UMC::UMC_OK)
                    return err;
            }
            if (frame->GetPictureType() != VC1_ENC_I_FRAME)
            {
                pFrameRef = m_pGOP->GetReferenceFrame();
                if (!pFrameRef)
                    return UMC::UMC_ERR_FAILED;

                err = m_pCurrPicture->SetPlaneParams  (pFrameRef, VC1_ENC_FORWARD_PLANE);
                if (err != UMC::UMC_OK)
                    return err;
            }
            if (frame->GetPictureType() == VC1_ENC_B_FRAME)
            {
                pFrameRef = m_pGOP->GetReferenceFrame(true);
                if (!pFrameRef)
                    return UMC::UMC_ERR_FAILED;

                err = m_pCurrPicture->SetPlaneParams  (pFrameRef, VC1_ENC_BACKWARD_PLANE);
                if (err != UMC::UMC_OK)
                    return err;
            }

            m_BitRateControl->GetQuant(frame->GetPictureType(), &m_uiPictuteQuantIndex, &m_bHalfQuant);

    #ifdef VC1_BRC_DEBUG
        printf("PicType = %d\n", frame->GetPictureType());
    #endif

            err = m_pCurrPicture->SetPictureParams(frame->GetPictureType(),m_iFrameCount%3,m_uiPictuteQuantIndex,m_bHalfQuant, m_pSavedMV);
            if (err != UMC::UMC_OK)
                return err;

            err = m_pCurrPicture->CheckParameters(m_cLastError);
            if (err != UMC::UMC_OK)
                return err;


            err = m_pCurrPicture->WritePictureHeader(m_CodedFrame);
            if (err != UMC::UMC_OK)
            return err;

            err = m_pCurrPicture->WriteFrame(m_CodedFrame);
            if (err != UMC::UMC_OK)
            return err;

    #ifdef VC1_ENC_DEBUG_ON
        //debug
        pDebug->SetPicType(frame->GetPictureType());
        pDebug->SetFrameSize(m_CodedFrame->GetDataLen() - seqHeaderLen - 8);
        pDebug->WriteFrameInfo();
    #endif

            //----------BRC------------
            err = m_BitRateControl->CheckFrameCompression(frame->GetPictureType(), m_CodedFrame->GetDataLen());
            if(err == UMC::UMC_OK)
                frame_recoding = false;
            else
                if((err == UMC::UMC_ERR_NOT_ENOUGH_BUFFER) && (m_uiPictuteQuantIndex == 31))
                frame_recoding = false;
            else
                if((err == UMC::UMC_ERR_NOT_ENOUGH_DATA) && (m_uiPictuteQuantIndex == 1))
                    frame_recoding = false;

            frame_recoding = frame_recoding & m_bFrameRecoding;
            RecodedFrameNum++;

            err = m_CodedFrame->DataComplete(out);
            if (err != UMC::UMC_OK)
            return err;

            if (frame->GetPictureType() != VC1_ENC_B_FRAME && m_uiGOPLength>1)
            {
                err = frame->PadFrameProgressive();
                if (err != UMC::UMC_OK)
                    return err;
            }
        }

        err = m_BitRateControl->CompleteFrame(frame->GetPictureType());
        //TODO: BRC error handling
        err = UMC::UMC_OK;

        m_pGOP->ReleaseCurrentFrame();
    }
    else if (!pVideoData)
    {
        return UMC::UMC_ERR_END_OF_STREAM;
    }

    /*------------------------------------------------------------------------------------------------------------*/

    if (pVideoData && !stored)
    {
        Frame*      in_frame           =  0;
        in_frame = m_pStoredFrames->GetFreeFramePointer();
        if (!in_frame)
            return UMC::UMC_ERR_NOT_ENOUGH_BUFFER;

        in_frame->CopyPlane( (Ipp8u*)pVideoData->GetPlanePointer(0), (Ipp32u)pVideoData->GetPlanePitch(0),
                             (Ipp8u*)pVideoData->GetPlanePointer(1), (Ipp32u)pVideoData->GetPlanePitch(1),
                             (Ipp8u*)pVideoData->GetPlanePointer(2), (Ipp32u)pVideoData->GetPlanePitch(2),
                             inputPictureType);

        if (!m_pWaitingList->AddFrame(in_frame))
            return UMC::UMC_ERR_NOT_ENOUGH_BUFFER;
         pVideoData->SetDataSize(0);
    }
    while ((frame = m_pWaitingList->GetCurrFrame())!=0)
    {
        if (!m_pGOP->AddFrame(frame))
            break;
            m_pWaitingList->MoveOnNextFrame();
    }
   /*------------------------------------------------------------------------------------------------------------*/

    return err;
}

void VC1EncoderADV::SetMemoryAllocator(UMC::MemoryAllocator *pMemoryAllocator, bool bOwnAllocator)
    {
         m_pMemoryAllocator = pMemoryAllocator;
         m_bOwnAllocator = bOwnAllocator;
    };

UMC::Status     VC1EncoderADV::Reset()
{
    UMC::Status umcSts = UMC::UMC_OK;

    m_pWaitingList->Reset();
    m_pGOP->Reset();
    m_BitRateControl->Reset();
    m_pStoredFrames->Reset();
    m_iFrameCount = 0;

    return umcSts;
}


UMC::Status VC1EncoderADV::GetInfo(UMC::VC1EncoderParams* pInfo)
{
   UMC::Status umcSts = UMC::UMC_OK;
   VC1BRInfo BRInfo;
   VC1_hrd_OutData HRDParam;

   if(!m_BitRateControl)
       return UMC::UMC_ERR_NOT_INITIALIZED;

   umcSts = m_BitRateControl->GetCurrentHRDParams(0,&HRDParam);
   if(umcSts != UMC::UMC_OK)
       return umcSts;

   umcSts = m_BitRateControl->GetBRInfo(&BRInfo);
   if(umcSts != UMC::UMC_OK)
       return umcSts;

   pInfo->qualityMeasure = -1;

   pInfo->info.bitrate      = BRInfo.bitrate;
   pInfo->info.framerate    = BRInfo.framerate;
   pInfo->m_iConstQuant     = BRInfo.constQuant;
   pInfo->m_uiHRDBufferSize = HRDParam.hrd_buffer;

   pInfo->m_uiGOPLength     = m_uiGOPLength;
   pInfo->m_uiBFrmLength    = m_uiBFrmLength;
   pInfo->m_uiMESearchSpeed = m_MESearchSpeed;
   pInfo->m_bFrameRecoding  = m_bFrameRecoding;

   pInfo->m_uiNumFrames     = m_iFrameCount;
   pInfo->numEncodedFrames  = m_iFrameCount;

   pInfo->level = m_SH->GetLevel();
   pInfo->info.stream_type    = UMC::VC1_VIDEO;
   pInfo->info.stream_subtype = UMC::VC1_VIDEO_VC1;
   pInfo->info.interlace_type = UMC::PROGRESSIVE;
   pInfo->info.color_format = UMC::YUV420;
   pInfo->info.streamPID = 0;
   pInfo->info.duration  = 0;
   pInfo->numThreads     = 0;

   pInfo->info.clip_info.height = m_SH->GetPictureHeight();
   pInfo->info.clip_info.width  = m_SH->GetPictureWidth();
   pInfo->m_bDeblocking = m_SH->IsLoopFilter();
   pInfo->m_bVSTransform = m_SH->IsVSTransform();
   pInfo->profile = VC1_ENC_PROFILE_A;

   pInfo->info.aspect_ratio_width = 1;
   pInfo->info.aspect_ratio_height = 1;

   pInfo->m_SuggestedOutputSize = 0;
   pInfo->m_SuggestedInputSize  =  0;

   pInfo->m_pData = NULL;

   return umcSts;
}
}


#endif //defined (UMC_ENABLE_VC1_VIDEO_ENCODER)