dx_drv.cpp

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

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

/* vm_status */
VIDEO_DRV_INIT_FUNC (umc_blt_Init, driver, params)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_Init"
    vm_status           result  = VM_OK;
    BLTDrv*             drv     = (BLTDrv*)ippsMalloc_8u(sizeof(BLTDrv));
    BLTVideoDrvParams*  pParams = (BLTVideoDrvParams*) params;
    IDirectDrawClipper* clipper = NULL;

    DBG_SET("+");
    if (VM_OK == result)
    {
        if (NULL == drv)
        {
            ERR_SET(VM_OPERATION_FAILED, "memory allocation");
        }
    }
    if (VM_OK == result)
    {
        if ((NULL == driver) || (NULL == pParams))
        {
            ERR_SET(VM_NULL_PTR, "null ptr");
        }
    }
    if (VM_OK == result)
    {
        driver->m_pDrv          = drv;
        driver->img_width       = pParams->common.img_width;
        driver->img_height      = pParams->common.img_height;
        driver->m_VideoMemType  = VideoDrvVideoMemLibrary;
        ippsZero_8u((Ipp8u*)&(driver->m_VideoMemInfo), sizeof(VideoDrvVideoMemInfo));
        ippsCopy_8u((const Ipp8u*)&BLTVideoDrvSpec, (Ipp8u*)&(driver->m_DrvSpec), sizeof(VideoDrvSpec));

        ippsZero_8u((Ipp8u*)drv, sizeof(DXDrv));
        drv->win        = pParams->win;
        drv->win_width  = pParams->common.win_rect.w;
        drv->win_height = pParams->common.win_rect.h;
        drv->dd_fmt     = pParams->dd_fmt;
    }
    if (VM_OK == result)
    {
        result = umc_dx_InitDDObjs(driver);
    }
    if (VM_OK == result)
    {
        if ((NULL == drv->dd_obj) ||
            (false == drv->dd_support_overlay) && (false == drv->dd_support_colorkey))
        {
            ERR_SET(VM_NOT_INITIALIZED, "initialization");
        }
    }
    if (VM_OK == result)
    {
        if (FAILED(drv->dd_obj->SetCooperativeLevel(drv->win, DDSCL_NORMAL)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDraw::SetCooperativeLevel");
        }
    }
    if (VM_OK == result)
    {
        /* Creating the primary surface. */
        INIT_DIRECTDRAW_STRUCT(drv->dd_srf_desc);
        drv->dd_srf_desc.dwFlags        = DDSD_CAPS;
        drv->dd_srf_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

        if (FAILED(drv->dd_obj->CreateSurface(&(drv->dd_srf_desc),
                                              &(drv->dd_srf_primary), 0)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDraw::CreateSurface");
        }
    }
    if (VM_OK == result)
    {
        if (FAILED(drv->dd_obj->CreateClipper(0, &clipper, 0)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDraw::CreateClipper");
        }
    }
    if (VM_OK == result)
    {
        if (FAILED(clipper->SetHWnd(0, drv->win)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDrawClipper::SetHWnd");
        }
    }
    if (VM_OK == result)
    {
        if (FAILED(drv->dd_srf_primary->SetClipper(clipper)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDrawSurface::SetClipper");
        }
    }
    if (VM_OK != result)
    {
        if (drv != NULL) { ippsFree(drv); driver->m_pDrv = NULL; }
    }
    DBG_SET("-");
    return result;
}

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

/* void */
VIDEO_DRV_CLOSE_FUNC (umc_blt_Close, driver)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_Close"
    vm_status           result  = VM_OK;
    DXDrv*              drv     = (DXDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    IDirectDrawClipper* clipper = NULL;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        if (NULL != drv->dd_srf_primary)
        {
            if (SUCCEEDED(drv->dd_srf_primary->GetClipper(&clipper)))
                clipper->Release();
        }
    }
    if (VM_OK == result)
    {
        umc_dx_Close(driver);
    }
    DBG_SET("-");
}

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

/* vm_status */
VIDEO_DRV_SET_VIDEO_MODE_FUNC(umc_blt_SetVideoMode, driver, rect, mode)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_SetVideoMode"
    vm_status           result  = VM_OK;
    DXDrv*              drv     = (DXDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    IDirectDrawClipper* clipper = NULL;

    DBG_SET("+");
    if (VM_OK == result)
    {
        if (NULL == drv)
        {
            ERR_SET(VM_NULL_PTR, "null ptr");
        }
    }
    if (VM_OK == result)
    {
        if (NULL != drv->dd_srf_primary)
        {
            if (SUCCEEDED(drv->dd_srf_primary->GetClipper(&clipper)))
            {
                if (FAILED(clipper->SetHWnd(0, drv->win)))
                {
                    ERR_SET(VM_OPERATION_FAILED, "IDirectDrawClipper::SetHWnd");
                }
            }
            else
            {
                ERR_SET(VM_OPERATION_FAILED, "IDirectDrawSurface::GetClipper");
            }
        }
    }
    if (VM_OK == result)
    {
        umc_dx_SetVideoMode(driver, rect, mode);
    }
    DBG_SET("-");
    return result;
}

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

/* void* */
VIDEO_DRV_CREATE_SURFACE_FUNC(umc_blt_CreateSurface, driver)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_CreateSurface"
    vm_status           result      = VM_OK;
    BLTDrv*             drv         = (BLTDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    DDSURFACEDESC       ddsdOverlay;
    IDirectDrawSurface* alloc_srf   = NULL;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        /* Creating overlay buffers. */
        INIT_DIRECTDRAW_STRUCT(ddsdOverlay);
        ddsdOverlay.ddsCaps.dwCaps  = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
        ddsdOverlay.dwFlags         = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
        ddsdOverlay.dwWidth         = driver->img_width;
        ddsdOverlay.dwHeight        = driver->img_height;
        ddsdOverlay.ddpfPixelFormat = umc_dx_overlay_formats[drv->dd_fmt];

        if (FAILED(drv->dd_obj->CreateSurface(&ddsdOverlay, &alloc_srf, NULL)))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDraw::CreateSurface");
        }
    }
    if (VM_OK != result)
    {
        alloc_srf = NULL;
    }
    DBG_SET("-");
    return alloc_srf;
}

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

/* void */
VIDEO_DRV_FREE_SURFACE_FUNC(umc_blt_FreeSurface, driver, srf)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_FreeSurface"
    vm_status           result  = VM_OK;
    BLTDrv*             drv     = (BLTDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    IDirectDrawSurface* overlay = (IDirectDrawSurface*)srf;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        if (NULL != overlay) overlay->Release();
    }
    DBG_SET("-");
}

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

/* vm_status */
VIDEO_DRV_RENDER_FRAME_FUNC (umc_blt_RenderFrame, driver, frame, rect)
{
#undef  FUNCTION
#define FUNCTION "umc_blt_RenderFrame"
    vm_status           result      = VM_OK;
    DXDrv*              drv         = (DXDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    IDirectDrawSurface* overlay     = (IDirectDrawSurface*) frame;
    HRESULT             hRes;
    ::RECT              src, dst_rec, *dst = &dst_rec;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        src.left    = 0;
        src.top     = 0;
        src.right   = driver->img_width;
        src.bottom  = driver->img_height;
        if (NULL != rect)
        {
            dst->left    = rect->x;
            dst->top     = rect->y;
            dst->right   = rect->x + rect->w;
            dst->bottom  = rect->y + rect->h;
        }
        else
        {
            // render to current window
            ::POINT pt = {0,0};
            ::ClientToScreen(drv->win, &pt);
            ::GetClientRect(drv->win, dst);
            dst->left   += pt.x;
            dst->right  += pt.x;
            dst->top    += pt.y;
            dst->bottom += pt.y;
        }
        hRes = drv->dd_srf_primary->Blt(dst, overlay, &src, DDBLT_WAIT, 0);
        if (DDERR_INVALIDRECT == hRes)
        {
            DBG_SET("Blit surface: invalid rectangle");
            hRes = drv->dd_srf_primary->Blt(NULL, overlay, &src, DDBLT_WAIT, 0);
        }
        if (DDERR_SURFACELOST == hRes)
        {
            while (DDERR_SURFACELOST == hRes)
            {
                if (FAILED(overlay->IsLost()))
                    overlay->Restore();
                if (FAILED(drv->dd_srf_primary->IsLost()))
                    drv->dd_srf_primary->Restore();
                hRes = drv->dd_srf_primary->Blt(dst, overlay, &src, DDBLT_WAIT, 0);
                if (DDERR_INVALIDRECT == hRes)
                {
                    DBG_SET("Blit surface: invalid rectangle");
                        hRes = drv->dd_srf_primary->Blt(NULL, overlay, &src, DDBLT_WAIT, 0);
                }
                Sleep(5);
            }
        }
        if (FAILED(hRes))
        {
            ERR_SET(VM_OPERATION_FAILED, "IDirectDrawSurface::Blt");
        }
    }
    DBG_SET("-");
    return result;
}

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

#endif /* defined(UMC_ENABLE_BLT_VIDEO_RENDER) */

#endif // defined(UMC_ENABLE_DX_VIDEO_RENDER)