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

#include "unified_video_render.h"
#include <umc_video_data.h>
#include <ipps.h>

namespace UMC
{

#define MODULE          "UnifiedVideoRender:"
#define FUNCTION        "Unknown"
#define DBG_SET(msg)    VIDEO_DRV_DBG_SET   (MODULE, FUNCTION, msg)

UnifiedVideoRenderParams::UnifiedVideoRenderParams():
    m_pDrvSpec(NULL),
    m_pDrvParams(NULL),
    m_VideoMemType(VideoDrvVideoMemLibrary),
    m_pVideoMemInfo(NULL)
{
}

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

UnifiedVideoRenderParams::UnifiedVideoRenderParams(VideoDrvSpec* pDrvSpec,
                                                   void* pDrvParams)
{
    m_pDrvSpec      = pDrvSpec;
    m_pDrvParams    = pDrvParams;
}

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

UnifiedVideoRenderParams&
UnifiedVideoRenderParams::operator=(VideoRenderParams &From)
{
    color_format    = From.color_format;

    disp.left       = From.disp.left;
    disp.right      = From.disp.right;
    disp.top        = From.disp.top;
    disp.bottom     = From.disp.bottom;

    range.left      = From.range.left;
    range.right     = From.range.right;
    range.top       = From.range.top;
    range.bottom    = From.range.bottom;

    info            = From.info;
    lFlags          = From.lFlags;

    out_data_template = From.out_data_template;

    return *this;
}

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

UnifiedVideoRender::UnifiedVideoRender(void):
    m_bDefaultRendering(false)
{
#undef  FUNCTION
#define FUNCTION "UnifiedVideoRender"
    DBG_SET ("+");
    ippsZero_8u((Ipp8u*)&m_Driver, sizeof(VideoDriver));
    DBG_SET ("-");
}

UnifiedVideoRender::~UnifiedVideoRender(void)
{
#undef  FUNCTION
#define FUNCTION "~UnifiedVideoRender"
    DBG_SET ("+");
    Close();
    DBG_SET ("-");
}

Status UnifiedVideoRender::Init(MediaReceiverParams* pInit)
{
#undef  FUNCTION
#define FUNCTION "Init"
    DBG_SET ("+");
    Status                      umcRes  = UMC_OK;
    UnifiedVideoRenderParams*   pParams = DynamicCast<UnifiedVideoRenderParams>(pInit);

    if ((NULL == pParams) || (NULL == pParams->m_pDrvSpec))
    {
        umcRes = UMC_ERR_NULL_PTR;
    }
    if (UMC_OK == umcRes)
    {
        m_bDefaultRendering = (pParams->lFlags & FLAG_VREN_DEFAULTRECT)? true: false;
    }
    if (UMC_OK == umcRes)
    {
        if (NULL != pParams->m_pDrvSpec->drvInit)
        {
            umcRes = (Status)pParams->m_pDrvSpec->drvInit(&m_Driver,
                                                          pParams->m_pDrvParams);
        }
    }
    if (UMC_OK == umcRes)
    {
        void* buffers[MAX_FRAME_BUFFERS];

        memset(buffers, 0, (MAX_FRAME_BUFFERS)*sizeof(void*));
        /* Allocation of video buffers by a driver. */
        if (NULL != m_Driver.m_DrvSpec.drvCreateBuffers)
        {
            umcRes = (Status)m_Driver.m_DrvSpec.drvCreateBuffers(&m_Driver,
                                                                 MIN_FRAME_BUFFERS,
                                                                 MAX_FRAME_BUFFERS,
                                                                 (void**)buffers,
                                                                 pParams->m_VideoMemType,
                                                                 pParams->m_pVideoMemInfo);
        }
        /* Setting number of allocated buffers. */
        for (m_iBuffersNum = 0; m_iBuffersNum < MAX_FRAME_BUFFERS; ++m_iBuffersNum)
        {
            if (NULL == (m_Buffers[m_iBuffersNum].surface = buffers[m_iBuffersNum]))
                break;
        }
    }
    if (UMC_OK == umcRes)
    {
        umcRes = BaseVideoRender::Init(pInit);
    }
    DBG_SET ("-");
    return umcRes;
}

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

Status UnifiedVideoRender::Close(void)
{
#undef  FUNCTION
#define FUNCTION "Close"
    DBG_SET ("+");
    void*   buffers[MAX_FRAME_BUFFERS] = {NULL};
    Ipp32s  i;

    m_SuncMut.LockIfInitialized();
    GetDriverBuffers(buffers);
    if (NULL != m_Driver.m_DrvSpec.drvFreeBuffers)
    {
        m_Driver.m_DrvSpec.drvFreeBuffers(&m_Driver, m_iBuffersNum, buffers);
    }
    for (i = 0; i < m_iBuffersNum; i++) m_Buffers[i].surface = NULL;
    if (NULL != m_Driver.m_DrvSpec.drvClose)
    {
        m_Driver.m_DrvSpec.drvClose(&m_Driver);
    }
    m_SuncMut.UnlockIfInitialized();
    DBG_SET ("-");
    return BaseVideoRender::Close();
}

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

Status UnifiedVideoRender::SetFullScreen(ModuleContext& /*rContext*/,
                                         bool bFullScreen)
{
#undef  FUNCTION
#define FUNCTION "SetFullScreen"
    DBG_SET ("+");
    Status              umcRes = UMC_OK;
    VideoDrvVideoMode   mode = (bFullScreen)? VideoDrvFullScreen: VideoDrvOrdinary;

    m_LockBufMut.Lock();
    m_SuncMut.Lock();
    if (UMC_OK == umcRes)
    {
        if (NULL != m_Driver.m_DrvSpec.drvSetVideoMode)
        {
            VideoDrvRect rect;

            rect.x = m_dst_rect.left;
            rect.w = m_dst_rect.right - m_dst_rect.left;
            rect.y = m_dst_rect.top;
            rect.h = m_dst_rect.bottom - m_dst_rect.top;
            umcRes = (Status)m_Driver.m_DrvSpec.drvSetVideoMode(&m_Driver,
                                                                &rect,
                                                                mode);
        }
    }
    if (VideoDrvTrue == m_Driver.m_DrvSpec.drv_rebuf)
    {
        void* buffers[MAX_FRAME_BUFFERS] = {NULL};
        if (UMC_OK == umcRes)
        {
            Ipp32s  i;
            GetDriverBuffers(buffers);
            if (NULL != m_Driver.m_DrvSpec.drvFreeBuffers)
            {
                m_Driver.m_DrvSpec.drvFreeBuffers(&m_Driver, m_iBuffersNum, buffers);
            }
            for (i = 0; i < m_iBuffersNum; i++) m_Buffers[i].surface = NULL;
        }
        if (UMC_OK == umcRes)
        {
            /* Allocation of video buffers by a driver. */
            if (NULL != m_Driver.m_DrvSpec.drvCreateBuffers)
            {
                umcRes = (Status)m_Driver.m_DrvSpec.drvCreateBuffers(&m_Driver,
                                                                     MIN_FRAME_BUFFERS,
                                                                     MAX_FRAME_BUFFERS,
                                                                     buffers,
                                                                     m_Driver.m_VideoMemType,
                                                                     &(m_Driver.m_VideoMemInfo));
            }
            /* Setting number of allocated buffers. */
            for (m_iBuffersNum = 0; m_iBuffersNum < MAX_FRAME_BUFFERS; ++m_iBuffersNum)
            {
                if (NULL == (m_Buffers[m_iBuffersNum].surface = buffers[m_iBuffersNum]))
                    break;
            }
        }
    }
    m_SuncMut.Unlock();
    m_LockBufMut.Unlock();
    DBG_SET ("-");
    return umcRes;
}

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

Status UnifiedVideoRender::ResizeDisplay(UMC::RECT &disp, UMC::RECT &range)
{
#undef  FUNCTION
#define FUNCTION "ResizeDisplay"
    DBG_SET ("+");
    Status umcRes = BaseVideoRender::ResizeDisplay(disp, range);

    if(UMC_OK == umcRes)
    {
        ModuleContext Context;
        umcRes = SetFullScreen(Context, false);
    }
    DBG_SET ("-");
    return umcRes;
}

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

Status UnifiedVideoRender::GetRenderFrame(Ipp64f *pTime)
{
#undef  FUNCTION
#define FUNCTION "GetRenderFrame"
    DBG_SET ("+");