unified_video_render.cpp

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

    DBG_SET ("-");
    return BaseVideoRender::GetRenderFrame(pTime);
}
/* -------------------------------------------------------------------------- */

Status UnifiedVideoRender::RenderFrame()
{
#undef  FUNCTION
#define FUNCTION "RenderFrame"
    DBG_SET ("+");
    Status umcRes = UMC_OK;
    VideoDrvRect rect =
    {
        m_dst_rect.left,
        m_dst_rect.top,
        m_dst_rect.right  - m_dst_rect.left,
        m_dst_rect.bottom - m_dst_rect.top
    };

    if(m_iReadIndex < 0)
        umcRes = UMC_ERR_NOT_INITIALIZED;
    if(UMC_OK == umcRes)
    {
        m_SuncMut.Lock();
        Ipp32s  iReadI  = m_iReadIndex; // wee need read index after 'unlock'
        Ipp64f  fFrTime = m_Buffers[m_iReadIndex].frame_time;
        bool    bShow   = m_bShow;
        void*   overlay = m_Buffers[m_iReadIndex].surface;
        m_SuncMut.Unlock();

        if(bShow)
        {
            if (NULL != m_Driver.m_DrvSpec.drvRenderFrame)
            {
                umcRes = (Status)m_Driver.m_DrvSpec.drvRenderFrame(&m_Driver,
                                                                   overlay,
                                                                   ((m_bDefaultRendering)? NULL: &rect));
            }
        }
        if (UMC_OK == umcRes)
        {
            m_iLastFrameIndex = iReadI;
        }
        if (VIDEO_DRV_USE_DEBUG)
        {
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("%s: %s:"), MODULE, FUNCTION);
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("m_iReadIndex = %d, m_iBuffersNum = %d"),
                            iReadI, m_iBuffersNum);
            vm_debug_trace1(VM_DEBUG_INFO, VM_STRING("fr_time = %f"), fFrTime);
        }
        m_hFreeBufSema.Signal();
    }
    DBG_SET ("-");
    return umcRes;
}

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

Status UnifiedVideoRender::ShowLastFrame()
{
#undef  FUNCTION
#define FUNCTION "ShowLastFrame"
    DBG_SET ("+");
    Status umcRes = UMC_OK;
    VideoDrvRect rect =
    {
        m_dst_rect.left,
        m_dst_rect.top,
        m_dst_rect.right  - m_dst_rect.left,
        m_dst_rect.bottom - m_dst_rect.top
    };

    if(m_iLastFrameIndex < 0)
        umcRes = UMC_ERR_NOT_INITIALIZED;
    if(UMC_OK == umcRes)
    {
        m_SuncMut.Lock();
        Ipp32s  iReadI  = m_iReadIndex;
        Ipp64f  fFrTime = m_Buffers[m_iLastFrameIndex].frame_time;
        bool    bShow   = m_bShow;
        void*   overlay = m_Buffers[m_iLastFrameIndex].surface;
        m_SuncMut.Unlock();

        if(bShow)
        {
            if(NULL != m_Driver.m_DrvSpec.drvRenderFrame)
            {
                umcRes = (Status)m_Driver.m_DrvSpec.drvRenderFrame(&m_Driver,
                                                                   overlay,
                                                                   ((m_bDefaultRendering)? NULL: &rect));
            }
        }
        if (VIDEO_DRV_USE_DEBUG)
        {
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("%s: %s:"), MODULE, FUNCTION);
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("m_iLastFrameIndex = %d, m_iReadIndex = %d"),
                            m_iLastFrameIndex, iReadI);
            vm_debug_trace1(VM_DEBUG_INFO, VM_STRING("fr_time = %f"), fFrTime);
        }
    }
    DBG_SET ("-");
    return umcRes;
}

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

// This function will be changed: LockSurface(VideoData *vd)
Ipp32s UnifiedVideoRender::LockSurface(Ipp8u** vBuf)
{
#undef  FUNCTION
#define FUNCTION "LockSurface"
    DBG_SET ("+");
    Status  umcRes  = UMC_OK;
    Ipp32s  pitch    = 0;

    if (m_iWriteIndex < 0)
        umcRes = UMC_ERR_NOT_INITIALIZED;
    if (UMC_OK == umcRes)
    {
        Ipp8u*            overlay = (Ipp8u*)m_Buffers[m_iWriteIndex].surface;
        VideoDrvPlaneInfo   planes[VIDEO_DRV_MAX_PLANE_NUMBER] =
        {
            {overlay,   0,  m_Driver.m_VideoMemInfo.m_nBufSize},
            {NULL,      0,  0}
        };

        if (NULL != m_Driver.m_DrvSpec.drvLockSurface)
        {
            umcRes = (Status)m_Driver.m_DrvSpec.drvLockSurface(&m_Driver,
                                                               overlay,
                                                               planes);
        }
        if (UMC_OK == umcRes)
        {
            if (VideoDrvVideoMemLibrary == m_Driver.m_VideoMemType)
            {
                pitch = planes[0].m_nPitch;
                if (NULL != vBuf)
                    *vBuf = (Ipp8u*)planes[0].m_pPlane;
            }
            else
            {
                /* !!! See function comment. */
                /* All information (pitches, planes) can be calculated. */
                VideoData tmp_data;

                tmp_data.SetAlignment(m_Driver.m_VideoMemInfo.m_nAlignment);
                tmp_data.Init(m_Driver.img_width, m_Driver.img_height, m_OutDataTemplate.GetColorFormat());
                //tmp_data.SetSurface(overlay, m_Driver.m_VideoMemInfo.m_nBufSize);
                tmp_data.SetBufferPointer((Ipp8u*)planes[0].m_pPlane/*overlay*/, planes[0].m_nMemSize/*m_Driver.m_VideoMemInfo.m_nBufSize*/);
                pitch = tmp_data.GetPlanePitch(0);
                if (NULL != vBuf) *vBuf = (Ipp8u*)tmp_data.GetPlanePointer(0);
            }
        }
    }
    if ((UMC_OK == umcRes) && VIDEO_DRV_USE_DEBUG)
    {
        vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("%s: %s:"), MODULE, FUNCTION);
        vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("m_iWriteIndex = %d, m_iBuffersNum = %d"),
                        m_iWriteIndex, m_iBuffersNum);
    }
    DBG_SET ("-");
    return pitch;
}

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

Ipp32s UnifiedVideoRender::UnlockSurface(Ipp8u** /*vBuf*/)
{
#undef  FUNCTION
#define FUNCTION "UnlockSurface"
    DBG_SET ("+");
    Status  umcRes  = UMC_OK;
    Ipp32s  ret_val = 0;

    if (m_iWriteIndex < 0)
    {
        umcRes = UMC_ERR_NOT_INITIALIZED;
    }
    if (UMC_OK == umcRes)
    {
        if (NULL != m_Driver.m_DrvSpec.drvUnlockSurface)
        {
            void *overlay = m_Buffers[m_iWriteIndex].surface;
            umcRes = (Status)m_Driver.m_DrvSpec.drvUnlockSurface(&m_Driver, overlay);
        }
    }
    if (UMC_OK == umcRes)
    {
        if (VIDEO_DRV_USE_DEBUG)
        {
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("%s: %s:"), MODULE, FUNCTION);
            vm_debug_trace2(VM_DEBUG_INFO, VM_STRING("m_iWriteIndex = %d, m_iBuffersNum = %d\n"),
                            m_iWriteIndex, m_iBuffersNum);
        }
        ret_val = 1;
    }
    else
        ret_val = 0;
    DBG_SET ("-");
    return ret_val;
}

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

void UnifiedVideoRender::GetDriverBuffers(void* buffers[MAX_FRAME_BUFFERS])
{
#undef  FUNCTION
#define FUNCTION "GetDriverBuffers"
    DBG_SET ("+");
    Ipp32s  i;

    ippsZero_8u((Ipp8u*)buffers, (MAX_FRAME_BUFFERS)*sizeof(void*));
    for (i = 0; i < m_iBuffersNum; ++i) buffers[i] = m_Buffers[i].surface;
    DBG_SET ("-");
}

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

void* UnifiedVideoRender::GetWindow(void)
{
#undef  FUNCTION
#define FUNCTION "GetWindow"
    DBG_SET ("+");
    void*   ret_val = NULL;

    if (NULL != m_Driver.m_DrvSpec.drvGetWindow)
    {
        ret_val = m_Driver.m_DrvSpec.drvGetWindow(&m_Driver);
    }
    DBG_SET ("-");
    return ret_val;
}

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

Status UnifiedVideoRender::RunEventLoop(void)
{
#undef  FUNCTION
#define FUNCTION "RunEventLoop"
    DBG_SET ("+");
    Status umcRes = UMC_OK;

    if (UMC_OK == umcRes)
    {
        if (NULL != m_Driver.m_DrvSpec.drvRunEventLoop)
        {
            umcRes = (Status)m_Driver.m_DrvSpec.drvRunEventLoop(&m_Driver);
        }
    }
    DBG_SET ("-");
    return umcRes;
}

} /* namespace UMC */