//
//  Copyright(C) Renesas Technology Corp. 1998-2004. All rights reserved.
//  Portions Copyright (c) 1997-1998 Microsoft Corporation.
//
//  NCG Display Driver for ITS-DS7
//
//  FILE      : halsurf.cpp
//  CREATED   : 2003.08.28
//  MODIFIED  : 2004.09.02
//  AUTHOR    : Renesas Technology Corp.
//  HARDWARE  : RENESAS ITS-DS7
//  HISTORY   : 
//              2003.08.28
//              - Created prototype code.
//                (based on Q2SD Display Driver for PFM-DS6C Ver.3.1.0)
//              2003.11.18
//              - Removed unused code.
//              2004.03.01
//              - Removed unused code.
//              2004.09.02
//              - Removed unused code.
//

#include "precomp.h"

DWORD WINAPI HalFlipToGDISurface( LPDDHAL_FLIPTOGDISURFACEDATA pd )
{
	DEBUGENTER( HalFlipToGDISurface );
	/*
	typedef struct _DDHAL_FLIPTOGDISURFACEDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL    lpDD;             // driver struct
		DWORD                      dwToGDI;          // TRUE if flipping to the GDI surface, FALSE if flipping away
		DWORD                      dwReserved;       // reserved for future use
		HRESULT                    ddRVal;           // return value
		LPDDHAL_FLIPTOGDISURFACE   FlipToGDISurface; // PRIVATE: ptr to callback
	} DDHAL_FLIPTOGDISURFACEDATA;
	*/

	// Implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalCreateSurface( LPDDHAL_CREATESURFACEDATA pd )
{
	DEBUGENTER( HalCreateSurface );
	/*
	typedef struct _DDHAL_CREATESURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDSURFACEDESC             lpDDSurfaceDesc;// description of surface being created
	    LPDDRAWI_DDRAWSURFACE_LCL   FAR *lplpSList; // list of created surface objects
	    DWORD                       dwSCnt;         // number of surfaces in SList
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_CREATESURFACE       CreateSurface;  // PRIVATE: ptr to callback
	} DDHAL_CREATESURFACEDATA;
	*/

    DWORD   dwFlags = pd->lpDDSurfaceDesc->dwFlags;
    DWORD   dwCaps = pd->lpDDSurfaceDesc->ddsCaps.dwCaps;
    LPDDPIXELFORMAT pddpf = (dwFlags & DDSD_PIXELFORMAT) ?
                        &(pd->lpDDSurfaceDesc->ddpfPixelFormat) : NULL;
    DWORD   dwBpp;

    if (pddpf != NULL) {
        if (pddpf->dwFlags & DDPF_RGB)
            dwBpp = pddpf->dwRGBBitCount;
        else
            dwBpp = 0;  // invalid bit depth
    }
    else
        dwBpp = NCGMode[0].gpeModeEx.modeInfo.Bpp;

    // Implementation

    if ((dwFlags & DDSD_CAPS) || (dwFlags & DDSD_ALL)) {
        DEBUGMSG(GPE_ZONE_CREATE,
            (TEXT("HalCreateSurface:dwCaps is 0x%08x.\r\n"), dwCaps));

        if (dwCaps & DDSCAPS_PRIMARYSURFACE) {
            if (pddpf != NULL && !(pddpf->dwFlags & DDPF_RGB)) {
                RETAILMSG(1,
                    (TEXT("HalCreateSurface: ")
                    TEXT("Unsupported non-linear primary surface.\r\n")));
                pd->ddRVal = DDERR_INVALIDPIXELFORMAT;
                return DDHAL_DRIVER_HANDLED;
            }
        }
        else if (dwCaps & DDSCAPS_OVERLAY) {
            RETAILMSG(1,
                (TEXT("HalCreateSurface: ")
                TEXT("Unsupported overlay surface.\r\n")));
            pd->ddRVal = DDERR_INVALIDCAPS;
            return DDHAL_DRIVER_HANDLED;
        }
    }
    else
        DEBUGMSG(GPE_ZONE_CREATE,
            (TEXT("HalCreateSurface: DDSCAPS is unused.\r\n")));

    // Other pixel format errors are checked in DetectPixelFormat.

	DDGPECreateSurface(pd);

	if (pd->ddRVal != DD_OK) {
		RETAILMSG(1, (TEXT("HalCreateSurface: DDGPECreateSurface failed.\r\n")));
		return DDHAL_DRIVER_HANDLED;
	}

	return DDHAL_DRIVER_HANDLED;
}


//////////////////////////// DDHAL_DDEXEBUFCALLBACKS ////////////////////////////

DWORD WINAPI HalCanCreateSurface( LPDDHAL_CANCREATESURFACEDATA pd )
{
	DEBUGENTER( HalCanCreateSurface );
	/*
	typedef struct _DDHAL_CANCREATESURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL	lpDD;				// driver struct
	    LPDDSURFACEDESC			lpDDSurfaceDesc;	// description of surface being created
	    DWORD					bIsDifferentPixelFormat;
	    											// pixel format differs from primary surface
	    HRESULT					ddRVal;				// return value
	    LPDDHAL_CANCREATESURFACE	CanCreateSurface;
	    											// PRIVATE: ptr to callback
	} DDHAL_CANCREATESURFACEDATA;
	*/

	// Implementation

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

    LPDDPIXELFORMAT pddpf = (dwFlags & DDSD_PIXELFORMAT) ?
                        &(pd->lpDDSurfaceDesc->ddpfPixelFormat) : NULL;
    DWORD   dwBpp;

    if (pddpf != NULL) {
        if (pddpf->dwFlags & DDPF_RGB)
            dwBpp = pddpf->dwRGBBitCount;
        else if (pddpf->dwFlags & DDPF_FOURCC)
            dwBpp = pddpf->dwRGBBitCount;
        else
            dwBpp = 0;  // invalid bit depth
    }
    else
        dwBpp = NCGMode[0].gpeModeEx.modeInfo.Bpp;

    // check dwHeight and dwWidth for avoiding restriction of DirectDraw
    if (((dwFlags & DDSD_HEIGHT) && (pd->lpDDSurfaceDesc->dwHeight >= 0x00010000)) ||
        ((dwFlags & DDSD_WIDTH ) && (pd->lpDDSurfaceDesc->dwWidth  >= 0x00010000))) {
        pd->ddRVal = DDERR_INVALIDPARAMS;
        goto CannotCreate;
    }

    // primary surface
    if (dwCaps & DDSCAPS_PRIMARYSURFACE) {
        // pixel format
        if (pddpf != NULL) {
            if (pddpf->dwFlags & (
                DDPF_FOURCC |
                DDPF_ALPHA | DDPF_ALPHAPIXELS | DDPF_ALPHAPREMULT |
                DDPF_BUMPLUMINANCE | DDPF_BUMPDUDV |
                DDPF_LUMINANCE | DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 |
                DDPF_PALETTEINDEXED4 | DDPF_RGBTOYUV | DDPF_STENCILBUFFER |
                DDPF_YUV | DDPF_ZBUFFER | DDPF_ZPIXELS)) {
                RETAILMSG(1,
                    (TEXT("HalCanCreateSurface: ")
                    TEXT("Unsupported pixel format for primary surface.\r\n")));
                pd->ddRVal = DDERR_INVALIDPIXELFORMAT;
                goto CannotCreate;
            }
        }

        if (dwBpp == 16)
            goto CanCreate;
        else {
            RETAILMSG(1,
                (TEXT("HalCanCreateSurface: ")
                TEXT("%dbpp not supported for primary surface.\r\n"),
                pddpf->dwRGBBitCount));
            pd->ddRVal = DDERR_INVALIDPIXELFORMAT;
            goto CannotCreate;
        }
    }

    // overlay surface
    else if (dwCaps & DDSCAPS_OVERLAY) {
        RETAILMSG(1,
            (TEXT("HalCanCreateSurface: ")
            TEXT("Unsupported overlay surface.\r\n")));
        pd->ddRVal = DDERR_INVALIDCAPS;
    }

    // offscreen surface
    else {
        // pixel format
        if (pddpf == NULL)
            goto CanCreate; // pixel format not specified
        else if (pddpf->dwFlags & (
            DDPF_ALPHA | DDPF_ALPHAPIXELS | DDPF_ALPHAPREMULT |
            DDPF_BUMPLUMINANCE | DDPF_BUMPDUDV |
            DDPF_LUMINANCE | DDPF_PALETTEINDEXED2 |
            DDPF_PALETTEINDEXED4 | DDPF_RGBTOYUV | DDPF_STENCILBUFFER |
            DDPF_YUV | DDPF_ZBUFFER | DDPF_ZPIXELS)) {
            RETAILMSG(1,
                (TEXT("HalCanCreateSurface: Unsupported pixel format for offscreen surface.\r\n")));
            pd->ddRVal = DDERR_INVALIDPIXELFORMAT;
            goto CannotCreate;
        }

        // other case, DirectDraw-compatible linearmapped offscreen
        if (dwBpp == 1 || dwBpp == 8 || dwBpp == 16)
            goto CanCreate;
        else {
            RETAILMSG(1,
                (TEXT("HalCanCreateSurface: %dbpp not supported for offscreen surface.\r\n"),
                dwBpp));
            pd->ddRVal = DDERR_INVALIDPIXELFORMAT;
            goto CannotCreate;
        }
    }

CanCreate:
    DEBUGMSG(GPE_ZONE_CREATE,
        (TEXT("HalCanCreateSurface: Accepted.\r\n")));
	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;

CannotCreate:
    DEBUGMSG(GPE_ZONE_CREATE,
        (TEXT("HalCanCreateSurface: Rejected.\r\n")));
    return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalCreateExecuteBuffer( LPDDHAL_CREATESURFACEDATA pd )
{
	DEBUGENTER( HalCreateExecuteBuffer );
	/*
	typedef struct _DDHAL_CREATESURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDSURFACEDESC             lpDDSurfaceDesc;// description of surface being created
	    LPDDRAWI_DDRAWSURFACE_LCL   FAR *lplpSList; // list of created surface objects
	    DWORD                       dwSCnt;         // number of surfaces in SList
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_CREATESURFACE       CreateSurface;  // PRIVATE: ptr to callback
	} DDHAL_CREATESURFACEDATA;
	*/

	// Implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalDestroyExecuteBuffer( LPDDHAL_DESTROYSURFACEDATA pd )
{
	DEBUGENTER( HalDestroyExecutebuffer );
	/*
	typedef struct _DDHAL_DESTROYSURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    HRESULT                     ddRVal;         // return value
	    LPDDHALSURFCB_DESTROYSURFACE DestroySurface;// PRIVATE: ptr to callback
		BOOL						fDestroyGlobal;
	} DDHAL_DESTROYSURFACEDATA;
	*/

	// Implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalLock( LPDDHAL_LOCKDATA pd )
{
	DEBUGENTER( HalLock );
	/*
	typedef struct _DDHAL_LOCKDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    DWORD                       bHasRect;       // rArea is valid
	    RECTL                       rArea;          // area being locked
	    LPVOID                      lpSurfData;     // pointer to screen memory (return value)
	    HRESULT                     ddRVal;         // return value
	    LPDDHALSURFCB_LOCK          Lock;           // PRIVATE: ptr to callback
	} DDHAL_LOCKDATA;
	*/