halsurf.cpp

来自「6410BSP3」· C++ 代码 · 共 533 行 · 第 1/2 页

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
// Copyright (c) Samsung Electronics. Co. LTD. All rights reserved.

/*++

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

    halsurf.cpp

Abstract:

    The Implementation HAL function to support DirectDraw

Functions:

    HalCreateSurface, ...

Notes:

--*/

#include "precomp.h"

DWORD
WINAPI
HalCreateSurface(LPDDHAL_CREATESURFACEDATA lpcsd)
{
    DEBUGENTER( HalCreateSurface );
    /*
    typedef struct _DDHAL_CREATESURFACEDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL lpDD;
        LPDDSURFACEDESC lpDDSurfaceDesc;
        LPDDRAWI_DDRAWSURFACE_LCL lplpSList;
        DWORD dwSCnt;
        HRESULT ddRVal;
    } DDHAL_CREATESURFACEDATA;
    */

    DWORD dwCaps = lpcsd->lpDDSurfaceDesc->ddsCaps.dwCaps;
    DWORD dwFlags = lpcsd->lpDDSurfaceDesc->dwFlags;

    // Handle Overlay Surface
    if (dwCaps & DDSCAPS_OVERLAY)
    {
        EGPEFormat format;
        EDDGPEPixelFormat pixelFormat;
        S3C6410Disp *pDDGPE = (S3C6410Disp *)GetDDGPE();

        lpcsd->ddRVal = pDDGPE->DetectPixelFormat(dwCaps, &lpcsd->lpDDSurfaceDesc->ddpfPixelFormat, &format, &pixelFormat);
        RETAILMSG(TRUE,(TEXT("CreateSurface:%d\n"),lpcsd->ddRVal));
        if (FAILED(lpcsd->ddRVal))
        {
            RETAILMSG(DISP_ZONE_ERROR, (_T("[DDHAL:ERR] HalCreateSurface() : Unsupported format\n\r")));

            return DDHAL_DRIVER_HANDLED;
        }

        // Create Overlay Surface with DDGPECreateSurface() function
        return DDGPECreateSurface(lpcsd);
    }
    else
    {
        // Pass to Non-overlay surface to DDGPECreateSurface() function
        return DDGPECreateSurface(lpcsd);
    }
}

DWORD WINAPI HalCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA lpccsd)
{
    DEBUGENTER( HalCanCreateSurface );
    /*
    typedef struct _DDHAL_CANCREATESURFACEDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL lpDD;
        LPDDSURFACEDESC lpDDSurfaceDesc;
        DWORD bIsDifferentPixelFormat;
        HRESULT ddRVal;
    } DDHAL_CANCREATESURFACEDATA;

    */

    DDPIXELFORMAT *pddpf = &lpccsd->lpDDSurfaceDesc->ddpfPixelFormat;
    DWORD dwCaps = lpccsd->lpDDSurfaceDesc->ddsCaps.dwCaps;
    DWORD dwWidth = lpccsd->lpDDSurfaceDesc->dwWidth;
    DWORD dwHeight = lpccsd->lpDDSurfaceDesc->dwHeight;

    RETAILMSG(DISP_ZONE_TEMP, (_T("HalCanCreateSurface. dwCaps : 0x%x, dwWidth:%d, dwHeight:%d\n"), dwCaps, dwWidth, dwHeight));    

    S3C6410Disp *pDDGPE = (S3C6410Disp *)GetDDGPE();

    // We do Not allow Primary Surface in System Memory
    if ((dwCaps & DDSCAPS_PRIMARYSURFACE) && (dwCaps & DDSCAPS_SYSTEMMEMORY))
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DDHAL:ERR] HalCanCreateSurface() : Can Not create Primary Surface in System Memory\n\r")));
        goto CannotCreate;
    }

    if ((dwCaps & DDSCAPS_OVERLAY) && (dwCaps & DDSCAPS_SYSTEMMEMORY))
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DDHAL:ERR] HalCanCreateSurface() : Can Not create Overlay Surface in System Memory\n\r")));
        goto CannotCreate;
    }

    if (dwCaps & DDSCAPS_PRIMARYSURFACE)
    {
        RETAILMSG(DISP_ZONE_TEMP, (_T("DiffPixel:%d\n"), lpccsd->bIsDifferentPixelFormat));
        if (lpccsd->bIsDifferentPixelFormat)
        {
            goto CannotCreate;
        }
        else
        {
            goto CanCreate;
        }
    }
    else if (dwCaps & DDSCAPS_OVERLAY)
    {
        EGPEFormat Format;
        EDDGPEPixelFormat PixelFormat;

        lpccsd->ddRVal = pDDGPE->DetectPixelFormat(dwCaps, pddpf, &Format, &PixelFormat);
        if (FAILED(lpccsd->ddRVal))
        {
            goto CannotCreate;
        }
        else
        {
            RETAILMSG(TRUE, (_T("PixelFormat :%d\n"), PixelFormat));
            switch(PixelFormat)
            {
            case ddgpePixelFormat_565:
            //case ddgpePixelFormat_8880:    // FIMD can not support Packed RGB888
            case ddgpePixelFormat_8888:
            case ddgpePixelFormat_I420:
            case ddgpePixelFormat_YV12:
            case ddgpePixelFormat_YUYV:
            case ddgpePixelFormat_YUY2:
            case ddgpePixelFormat_UYVY:
             case ddgpePixelFormat_YVYU:
            case ddgpePixelFormat_VYUY:
                goto CanCreate;
                break;
            default:
                goto CannotCreate;
                break;
            }
        }
    }
    else        // Non Primary, Non Overlay Surface (Maybe Offscreen Surface)
    {
        return DDGPECanCreateSurface(lpccsd);
    }

CanCreate:

    RETAILMSG(DISP_ZONE_ENTER,(_T("[DDHAL] HalCanCreateSurface() OK\n\r")));
    lpccsd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;

CannotCreate:

    RETAILMSG(DISP_ZONE_ERROR, (_T("[DDHAL:ERR] HalCanCreateSurface() : Unsupported Surface\n\r")));
    lpccsd->ddRVal = DDERR_UNSUPPORTEDFORMAT;

    return DDHAL_DRIVER_HANDLED;
}

//////////////////////////// DDHAL_DDSURFACECALLBACKS ////////////////////////////

DWORD
WINAPI
HalFlip(LPDDHAL_FLIPDATA lpfd)
{
    DEBUGENTER( HalFlip );
    /*
    typedef struct _DDHAL_FLIPDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL lpDD;
        LPDDRAWI_DDRAWSURFACE_LCL lpSurfCurr;
        LPDDRAWI_DDRAWSURFACE_LCL lpSurfTarg;
        DWORD dwFlags;
        HRESULT ddRVal;
    } DDHAL_FLIPDATA;
    */

    S3C6410Disp *pDDGPE = (S3C6410Disp *)GetDDGPE();
    DWORD dwFlags = lpfd->dwFlags;

    if (dwFlags & (DDFLIP_INTERVAL1|DDFLIP_INTERVAL2|DDFLIP_INTERVAL4))
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DDHAL:ERR] HalFlip() : DDFLIP_INTERVAL is not supported\n\r")));
        lpfd->ddRVal = DDERR_UNSUPPORTED;
    }
    else
    {
        if (dwFlags & DDFLIP_WAITNOTBUSY)
        {
            // Our H/W always not busy.. This will be skipped
            while(((S3C6410Disp *)GetDDGPE())->IsBusy());
        }

        DDGPESurf* surfTarg = DDGPESurf::GetDDGPESurf(lpfd->lpSurfTarg);

        if (dwFlags & DDFLIP_WAITVSYNC)
        {
            pDDGPE->SetVisibleSurface(surfTarg, TRUE);
        }
        else
        {
            pDDGPE->SetVisibleSurface(surfTarg, FALSE);
        }

        lpfd->ddRVal = DD_OK;
    }

    DEBUGLEAVE( HalFlip );

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetBltStatus( LPDDHAL_GETBLTSTATUSDATA lpgbsd )
{
    DEBUGENTER( HalGetBltStatus );
    /*
    typedef struct _DDHAL_GETBLTSTATUSDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL lpDD;
        LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface;
        DWORD dwFlags;
        HRESULT ddRVal;
    } DDHAL_GETBLTSTATUSDATA;
    */

    // Implementation
    lpgbsd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetFlipStatus( LPDDHAL_GETFLIPSTATUSDATA lpgfsd)
{
    DEBUGENTER( HalGetFlipStatus );
    /*
    typedef struct _DDHAL_GETFLIPSTATUSDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL lpDD;
        LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface;
        DWORD dwFlags;
        HRESULT ddRVal;
    } DDHAL_GETFLIPSTATUSDATA;
    */