umc_vc1_video_decoder.cpp

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

#ifdef CREATE_ES
    if (m_fPureVideo)
        fclose(m_fPureVideo);
#endif
#ifdef _PROJECT_STATISTICS_
    if(m_timeStatistics)
        WriteStatisticResults();
    DeleteStatistics();
#endif
    FreeAlloc(m_pContext);

    if(m_pMemoryAllocator)
    {
        m_pMemoryAllocator->Unlock(m_pNewMemID);

        if(m_bOwnAllocator == true) // probably always?
        {
            m_pMemoryAllocator->Free(m_pNewMemID);

        }

        m_pNewMemID = (MemID)-1;
        //ippsFree(m_pContext->m_frmBuff.m_pFrames[0].m_pAllocatedMemory);
        //m_pContext->m_frmBuff.m_pFrames[0].m_pAllocatedMemory = NULL;
    }
    BaseCodec::Close(); // delete internal allocator if exists


    if(m_pContext)
    {
        if (m_pContext->m_frmBuff.m_pFrames)
        {
            delete m_pContext->m_frmBuff.m_pFrames;
            m_pContext->m_frmBuff.m_pFrames = NULL;
        }
        ippsFree(m_pContext);
        m_pContext = NULL;
    }

    if(m_dataBuffer)
    {
        ippsFree(m_dataBuffer);
        m_dataBuffer = NULL;
    }

    if(m_stCodes)
    {
        ippsFree(m_stCodes);
        m_stCodes = NULL;
    }

    if(m_frameData)
    {
        delete m_frameData;
        m_frameData = NULL;
    }


    VM_Debug::GetInstance(VC1DebugFree).Release();

    m_iThreadDecoderNum = 0;
    m_decoderInitFlag = 0;
    m_decoderFlags = 0;
    return umcRes;
}


Status VC1VideoDecoder::Reset(void)
{
    Status umcRes = UMC_OK;
    //VC1TaskStore* pStore = VC1TaskStore::GetInstance(VC1Routine);

    if (m_pStore)
        m_pStore->StopDecoding();


    if(m_pContext==NULL || m_pContext->m_seqLayerHeader == NULL)
        return UMC_ERR_NOT_INITIALIZED;

    if(m_pdecoder)
    {
        for(Ipp32u i = 1; i < m_iThreadDecoderNum; i += 1)
        {
            if(m_pdecoder[i])
            {
                //m_pdecoder[i]->WaitAndStop();
                m_pdecoder[i]->WaitForEndOfProcessing();
            }
        }
    }

    m_bIsWarningStream = false;
    m_bLastFrameNeedDisplay = false;
    m_pStore->FreeIndexQueue();
    m_pStore->ResetDSQueue();
    m_pStore->Reset();
    m_lFrameCount = 0;
    m_iRefFramesDst = 0;
    m_iBFramesDst = 0;

    m_pContext->m_frmBuff.m_iDisplayIndex =  0;
    m_pContext->m_frmBuff.m_iCurrIndex    =  0;
    m_pContext->m_frmBuff.m_iPrevIndex    =  0;
    m_pContext->m_frmBuff.m_iNextIndex    =  1;
    //m_pContext->m_frmBuff.m_iICompIndex   =  3;

    //memset(m_pContext->m_picLayerHeader, 0, sizeof(VC1PictureLayerHeader));

    if (m_pContext->m_pSingleMB)
    {
        m_pContext->m_pSingleMB->m_currMBXpos = -1;
        m_pContext->m_pSingleMB->m_currMBYpos = 0;
    }

    m_pContext->m_pCurrMB = &m_pContext->m_MBs[0];
    m_pContext->CurrDC = m_pContext->DCACParams;
    m_pContext->DeblockInfo.HeightMB = 0;
    m_pContext->DeblockInfo.start_pos = 0;
    m_pContext->DeblockInfo.is_last_deblock = 1;
    return umcRes;
}


Status VC1VideoDecoder::GetInfo(BaseCodecParams* pbInfo)
{
    Status umcRes = UMC_OK;

    VideoDecoderParams *pInfo = DynamicCast<VideoDecoderParams> (pbInfo);

    //check initialization
    if(m_pContext==NULL || m_pContext->m_seqLayerHeader == NULL)
        return UMC_ERR_NOT_INITIALIZED;

    // check error(s)
    if (NULL == pInfo)
        return UMC_ERR_NULL_PTR;


    pInfo->info.clip_info.width  = 2*(m_pContext->m_seqLayerHeader->MAX_CODED_WIDTH + 1);
    pInfo->info.clip_info.height = 2*(m_pContext->m_seqLayerHeader->MAX_CODED_HEIGHT + 1);
    return umcRes;
}


Status VC1VideoDecoder::GetPerformance(Ipp64f /**perf*/)
{
    Status umcRes = UMC_OK;
    return umcRes;
}


Status VC1VideoDecoder::ResetSkipCount()
{
    Status umcRes = UMC_OK;
    return umcRes;
}


Status VC1VideoDecoder::SkipVideoFrame(Ipp32s)
{
    Status umcRes = UMC_OK;
    return umcRes;
}


Ipp32u VC1VideoDecoder::GetNumOfSkippedFrames()
{
    return 0;
}


Status VC1VideoDecoder::ResizeBuffer()
{
    Ipp32u newSize =  0;
    Ipp32u bufferSize = 0;

    if(m_pContext && m_pContext->m_seqLayerHeader && m_pContext->m_seqLayerHeader->heightMB
        && m_pContext->m_seqLayerHeader->heightMB)

        newSize = (m_pContext->m_seqLayerHeader->heightMB*VC1_PIXEL_IN_LUMA + 128)*
                        (m_pContext->m_seqLayerHeader->widthMB*VC1_PIXEL_IN_LUMA + 128)
                        + ((m_pContext->m_seqLayerHeader->heightMB*VC1_PIXEL_IN_CHROMA + 64)
                        *(m_pContext->m_seqLayerHeader->widthMB*VC1_PIXEL_IN_CHROMA + 64))*2;

    else
        newSize = m_frameData->GetBufferSize() + 2048;

    if(m_dataBuffer)
    {
        ippsFree(m_dataBuffer);
        m_dataBuffer = NULL;
    }

    //buf size should be divisible by 4
    if(newSize & 0x00000003)
        bufferSize = (newSize&0xFFFFFFFC) + 4;
    else
        bufferSize = newSize;

    m_dataBuffer = (Ipp8u*)ippsMalloc_8u(bufferSize*sizeof(Ipp8u));
    if(m_dataBuffer==NULL)
    {
        return UMC_ERR_ALLOC;
    }

    memset(m_dataBuffer, 0, bufferSize);
    m_frameData->SetBufferPointer(m_dataBuffer, bufferSize);
    m_frameData->SetDataSize(bufferSize);

    return UMC_OK;
}

void VC1VideoDecoder::GetPTS(Ipp64f in_pts)
{
   if(in_pts == -1 && m_pts == -1)
       m_pts = 0;
   else if (in_pts == -1)
   {
       if(m_ClipInfo.framerate)
        m_pts = m_pts + 1.0/m_ClipInfo.framerate - m_pts_dif;
       else
        m_pts = m_pts + 1.0/24 - m_pts_dif;
   }
   else
   {
       if(m_pts_dif == 0)
       {
           if(m_ClipInfo.framerate)
                m_pts = m_pts + 1.0/m_ClipInfo.framerate - m_pts_dif;
           else
                m_pts = m_pts + 1.0/24 - m_pts_dif;

           m_pts_dif = in_pts - m_pts;
       }
       else
       {
            if(m_ClipInfo.framerate)
                m_pts = m_pts + 1.0/m_ClipInfo.framerate - m_pts_dif;
            else
                m_pts = m_pts + 1.0/24 - m_pts_dif;
       }
   }
}

void VC1VideoDecoder::GetFPS()
{
    if((m_ClipInfo.stream_subtype == VC1_VIDEO_VC1)||(m_ClipInfo.stream_subtype == WVC1_VIDEO))
    {
        m_ClipInfo.bitrate = m_pContext->m_seqLayerHeader->BITRTQ_POSTPROC;
        m_ClipInfo.framerate = m_pContext->m_seqLayerHeader->FRMRTQ_POSTPROC;

        //for advanced profile
        if ((m_ClipInfo.framerate == 0) && (m_ClipInfo.bitrate == 31))
            {
                //Post processing indicators for Frame Rate and Bit Rate are undefined
                m_ClipInfo.bitrate = 0;
            }
            else if ((m_ClipInfo.framerate == 0) && (m_ClipInfo.bitrate == 30))
            {
                m_ClipInfo.framerate =  2;
                m_ClipInfo.bitrate = 1952;
            }
            else if ((m_ClipInfo.framerate == 1) && (m_ClipInfo.bitrate == 31))
            {
                m_ClipInfo.framerate =  6;
                m_ClipInfo.bitrate = 2016;
            }
            else
            {
                if (m_ClipInfo.framerate == 7)
                    m_ClipInfo.framerate = 30;
                else
                    m_ClipInfo.framerate = (2 + m_ClipInfo.framerate*4);

                if (m_ClipInfo.bitrate == 31)
                    m_ClipInfo.bitrate = 2016;
                else
                    m_ClipInfo.bitrate = (32 + m_ClipInfo.bitrate * 64);
            }
    }
    else if (m_ClipInfo.stream_subtype != WMV3_VIDEO)
    {
        m_ClipInfo.bitrate = m_pContext->m_seqLayerHeader->BITRTQ_POSTPROC;
        m_ClipInfo.framerate = m_pContext->m_seqLayerHeader->FRMRTQ_POSTPROC;
    }

    if(m_ClipInfo.framerate<=0)
        m_ClipInfo.framerate = 24;

}


Status VC1VideoDecoder::WriteFrame(MediaData* in_UpLeveldata, VC1Context* pContext, UMC::VideoData* out_data)
{
STATISTICS_START_TIME(m_timeStatistics->ColorConv_StartTime);
    IppiSize roiSize;
    Status vc1_sts;

    roiSize.height = 2*(pContext->m_seqLayerHeader->MAX_CODED_HEIGHT+1);
    roiSize.width = 2*(pContext->m_seqLayerHeader->MAX_CODED_WIDTH+1);

    Ipp32s Index = pContext->m_frmBuff.m_iDisplayIndex;
    UMC::VideoData in_data;
    Ipp64f start_pts =  -1;
    Ipp64f end_pts =  -1;

    in_data.Init(roiSize.width, roiSize.height, YUV_VC1);

    if (m_pContext->m_seqLayerHeader->PROFILE != VC1_PROFILE_ADVANCED)
    {
        if (((pContext->m_picLayerHeader->RANGEREDFRM-1) == *pContext->m_frmBuff.m_pFrames[pContext->m_frmBuff.m_iDisplayIndex].pRANGE_MAPY)||
            (pContext->m_picLayerHeader->PTYPE != VC1_B_FRAME)||
            !m_bLastFrameNeedDisplay)

        {
            in_data.SetPlaneBitDepth(*pContext->m_frmBuff.m_pFrames[pContext->m_frmBuff.m_iDisplayIndex].pRANGE_MAPY, 0);
            in_data.SetPlaneBitDepth(*pContext->m_frmBuff.m_pFrames[pContext->m_frmBuff.m_iDisplayIndex].pRANGE_MAPY, 1);
            in_data.SetPlaneBitDepth(*pContext->m_frmBuff.m_pFrames[pContext->m_frmBuff.m_iDisplayIndex].pRANGE_MAPY, 2);
        }
        //warning - B Range Reduction does not match anchor frame
        else
        {
            in_data.SetPlaneBitDepth(-1, 0);
            in_data.SetPlaneBitDepth(-1, 1);
            in_data.SetPlaneBitDepth(-1, 2);
        }

    }
    else
    {
        in_data.SetPlaneBitDepth(pContext->m_seqLayerHeader->RANGE_MAPY, 0);
        in_data.SetPlaneBitDepth(pContext->m_seqLayerHeader->RANGE_MAPUV, 1);
        in_data.SetPlaneBitDepth(pContext->m_seqLayerHeader->RANGE_MAPUV, 2);

    }

    in_data.SetPlanePointer((void*)pContext->m_frmBuff.m_pFrames[Index].m_pY, 0);
    in_data.SetPlanePointer((void*)pContext->m_frmBuff.m_pFrames[Index].m_pU, 1);
    in_data.SetPlanePointer((void*)pContext->m_frmBuff.m_pFrames[Index].m_pV, 2);
    in_data.SetPlanePitch(pContext->m_frmBuff.m_pFrames[Index].m_iYPitch, 0);
    in_data.SetPlanePitch(pContext->m_frmBuff.m_pFrames[Index].m_iUPitch, 1);
    in_data.SetPlanePitch(pContext->m_frmBuff.m_pFrames[Index].m_iVPitch, 2);

    if (in_UpLeveldata)
        in_UpLeveldata->GetTime(start_pts,end_pts);
    if (!m_bIsWMPSplitter)
        GetPTS(start_pts);
    else
        m_pts = end_pts;

    in_data.SetTime(start_pts,m_pts);

    vc1_sts = m_PostProcessing->GetFrame(&in_data, out_data);
STATISTICS_END_TIME(m_timeStatistics->ColorConv_StartTime,
                    m_timeStatistics->ColorConv_EndTime,
                    m_timeStatistics->ColorConv_TotalTime);
    return vc1_sts;
}

Status VC1VideoDecoder::CreateFrameBuffer()
{
    Ipp32u bufferSize = 1024;

    if(m_dataBuffer == NULL)
    {
        m_dataBuffer = (Ipp8u*)ippsMalloc_8u(bufferSize*sizeof(Ipp8u) + 4);