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

#include <umc_defs.h>

#ifdef UMC_ENABLE_GDI_VIDEO_RENDER

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

#include "gdi_drv.h"
#include <stdio.h>
#include <ipps.h>

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

#define MODULE              "GDI(video driver)"
#define FUNCTION            "<Undefined Function>"
#define ERR_STRING(msg)     VIDEO_DRV_ERR_STRING(MODULE, FUNCTION, msg)
#define ERR_SET(err, msg)   VIDEO_DRV_ERR_SET   (MODULE, err, FUNCTION, msg)
#define WRN_SET(err, msg)   VIDEO_DRV_WRN_SET   (MODULE, err, FUNCTION, msg)
#define DBG_SET(msg)        VIDEO_DRV_DBG_SET   (MODULE, FUNCTION, msg)

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

const VideoDrvSpec GDIVideoDrvSpec =
{
    VM_STRING(MODULE),
    VideoDrvFalse,
    VideoDrvVideoMemInternal | VideoDrvVideoMemExternal,
    umc_gdi_Init,
    umc_gdi_Close,
    umc_vdrv_CreateBuffers,
    umc_vdrv_FreeBuffers,
    NULL,
    NULL,
    umc_gdi_LockSurface,
    umc_gdi_UnlockSurface,
    umc_gdi_RenderFrame,
    umc_gdi_SetVideoMode,
    umc_gdi_GetWindow,
    NULL
};

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

Ipp32u umc_gdi_get_bpp_DC(HWND hWnd)
{
#undef  FUNCTION
#define FUNCTION "umc_gdi_Init"
    Ipp32u      bpp_DC  = 0;
    vm_status   result  = VM_OK;
    HDC         hDC     = NULL;

    if (VM_OK == result)
    {
        if (NULL == (hDC = ::GetDC(hWnd)))
        {
            ERR_SET(VM_OPERATION_FAILED, "GetDC");
        }
    }
    if (VM_OK == result)
    {
        if (0 == (bpp_DC = ::GetDeviceCaps(hDC, BITSPIXEL) >> 3))
        {
            ERR_SET(VM_OPERATION_FAILED, "GetDeviceCaps");
        }
    }
    if (VM_OK == result)
    {
        if (1 != ::ReleaseDC(hWnd, hDC))
        {
            ERR_SET(VM_OPERATION_FAILED, "ReleaseDC");
        }
    }
    return bpp_DC;
}

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

/* vm_status */
VIDEO_DRV_INIT_FUNC (umc_gdi_Init, driver, params)
{
#undef  FUNCTION
#define FUNCTION "umc_gdi_Init"
    vm_status           result  = VM_OK;
    GDIDrv*             drv     = (GDIDrv*)ippsMalloc_8u(sizeof(GDIDrv));
    GDIVideoDrvParams*  pParams = (GDIVideoDrvParams*) params;

    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*)&GDIVideoDrvSpec, (Ipp8u*)&(driver->m_DrvSpec), sizeof(VideoDrvSpec));

        ippsZero_8u((Ipp8u*)drv, sizeof(GDIDrv));
        drv->win                = pParams->win;
        drv->win_width          = pParams->common.win_rect.w;
        drv->win_height         = pParams->common.win_rect.h;
        drv->win_full_screen    = false;

        drv->gdi_in_color_format        = pParams->gdi_in_color_format;
        drv->gdi_out_color_format       = pParams->gdi_out_color_format;
        drv->gdi_bpp_DC                 = pParams->gdi_bpp_DC;
        if (drv->gdi_in_color_format != drv->gdi_out_color_format)
        {
            drv->gdi_YUV_buffer.m_nPitch    = pParams->gdi_YUV_buffer.m_nPitch;
            drv->gdi_YUV_buffer.m_nMemSize  = pParams->gdi_YUV_buffer.m_nMemSize;
            if (NULL != pParams->gdi_YUV_buffer.m_pPlane)
            {
                drv->gdi_YUV_buffer_type     = VideoDrvVideoMemInternal;
                drv->gdi_YUV_buffer.m_pPlane = pParams->gdi_YUV_buffer.m_pPlane;
            }
            else
            {
                drv->gdi_YUV_buffer_type     = VideoDrvVideoMemExternal;
                drv->gdi_YUV_buffer.m_pPlane = ippsMalloc_8u(drv->gdi_YUV_buffer.m_nMemSize*sizeof(Ipp8u));
            }
        }
    }
    if (VM_OK != result)
    {
        if (drv != NULL) { ippsFree(drv); driver->m_pDrv = NULL; }
    }
    DBG_SET("-");
    return result;
}

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

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

    DBG_SET("+");
    if (VM_OK == result)
    {
        if (NULL == drv)
        {
            ERR_SET(VM_NULL_PTR, "null ptr");
        }
    }
    if (VM_OK == result)
    {
        drv->win_full_screen = (VideoDrvFullScreen == mode)? true: false;
    }
    DBG_SET("-");
    return result;
}

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

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

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        if ((VideoDrvVideoMemInternal == drv->gdi_YUV_buffer_type) &&
            (NULL != drv->gdi_YUV_buffer.m_pPlane))
        {
            ippsFree(drv->gdi_YUV_buffer.m_pPlane);
        }
        ippsFree(drv);
        driver->m_pDrv = NULL;
    }
    DBG_SET("-");
}

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

/* vm_status */
VIDEO_DRV_LOCK_SURFACE_FUNC(umc_gdi_LockSurface, driver, srf, planes)
{
#undef  FUNCTION
#define FUNCTION "umc_gdi_LockSurface"
    vm_status   result  = VM_OK;
    GDIDrv*     drv     = (GDIDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    Ipp32s      i;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        if (drv->gdi_in_color_format != drv->gdi_out_color_format)
        {
            planes[0].m_pPlane      = drv->gdi_YUV_buffer.m_pPlane;
            planes[0].m_nPitch      = drv->gdi_YUV_buffer.m_nPitch;
            planes[0].m_nMemSize    = drv->gdi_YUV_buffer.m_nMemSize;
            for (i = 1; i < VIDEO_DRV_MAX_PLANE_NUMBER; ++i)
            {
                planes[i].m_pPlane      = NULL;
                planes[i].m_nPitch      = 0;
                planes[i].m_nMemSize    = 0;
            }
        }
    }
    DBG_SET("-");
    return result;
}

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

void umc_gdi_YV12_to_RGB32 (Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);
void umc_gdi_YV12_to_RGB24 (Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);
void umc_gdi_YV12_to_RGB555(Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);
void umc_gdi_YUY2_to_RGB32 (Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);
void umc_gdi_YUY2_to_RGB24 (Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);
void umc_gdi_YUY2_to_RGB555(Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);

typedef void ConverterFunc(Ipp8u* src, Ipp8u* dst, Ipp32u w, Ipp32u h);


/* vm_status */
VIDEO_DRV_UNLOCK_SURFACE_FUNC (umc_gdi_UnlockSurface, driver, srf)
{
#undef  FUNCTION
#define FUNCTION "umc_gdi_UnlockSurface"
    vm_status       result  = VM_OK;
    GDIDrv*         drv     = (GDIDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    ConverterFunc*  FuncTable[2][3] =
    {
        {umc_gdi_YV12_to_RGB32, umc_gdi_YV12_to_RGB24, umc_gdi_YV12_to_RGB555},
        {umc_gdi_YUY2_to_RGB32, umc_gdi_YUY2_to_RGB24, umc_gdi_YUY2_to_RGB555}
    };
    Ipp32u          iFrom = 0, iTo = 0;

    DBG_SET("+");
    if (VM_OK == result)
    {
        if (NULL == drv)
        {
            ERR_SET(VM_NULL_PTR, "null ptr");
        }
    }
    if (VM_OK == result)
    {
        if (drv->gdi_in_color_format != drv->gdi_out_color_format)
        {
            if (VM_OK == result)
            {
                switch (drv->gdi_in_color_format)
                {
                case UMC::YV12:
                    iFrom = 0;
                    break;
                case UMC::YUY2:
                    iFrom = 1;
                    break;
                default:
                    ERR_SET(VM_OPERATION_FAILED, "bad input color format");
                    break;
                }
            }
            if (VM_OK == result)
            {
                switch (drv->gdi_out_color_format)
                {
                case UMC::RGB32:
                    iTo = 0;
                    break;
                case UMC::RGB24:
                    iTo = 1;
                    break;
                case UMC::RGB555:
                    iTo = 2;
                    break;
                default:
                    ERR_SET(VM_OPERATION_FAILED, "bad output color format");
                    break;
                }
            }
            if (VM_OK == result)
            {
                FuncTable[iFrom][iTo]((Ipp8u*)drv->gdi_YUV_buffer.m_pPlane,
                        (Ipp8u*)srf,
                        driver->img_width, driver->img_height);
            }
        }
    }
    DBG_SET("-");
    return result;
}

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

/* vm_status */
VIDEO_DRV_RENDER_FRAME_FUNC (umc_gdi_RenderFrame, driver, frame, rect)
{
#undef  FUNCTION
#define FUNCTION "umc_gdi_RenderFrame"
    vm_status   result  = VM_OK;
    GDIDrv*     drv     = (GDIDrv*)((NULL != driver)? driver->m_pDrv: NULL);
    HDC         hDC     = NULL;
    ::RECT      dst;
    Ipp32s      iRes;

    DBG_SET("+");
    if (NULL == drv)
    {
        ERR_SET(VM_NULL_PTR, "null ptr");
    }
    if (VM_OK == result)
    {
        if (NULL == (hDC = ::GetDC(((drv->win_full_screen)? NULL: drv->win))))
        {
            ERR_SET(VM_OPERATION_FAILED, "GetDC");
        }
    }
    if (VM_OK == result)
    {
        ::POINT point = {0,0};
        ::ClientToScreen(drv->win, &point);
        if (NULL != rect)
        {
            dst.left    = rect->x;
            dst.top     = rect->y;
            dst.right   = rect->x + rect->w;
            dst.bottom  = rect->y + rect->h;
        }
        else
        {
            ::GetClientRect(drv->win, &dst);
            dst.left   += point.x;