reactos/win32ss/drivers/displays/framebufacc/ddenable.c
Hermès Bélusca-Maïto 52275a92bd
[WIN32SS:DISPLAY] Fix some return values (use correct types) in display drivers.
See for example, in DrvEnableSurface(), etc.

TODO: framebufacc's comments need to be "translated" into actual English...
2022-03-19 17:51:44 +01:00

261 lines
7.9 KiB
C

/*
* ReactOS Generic Framebuffer display driver directdraw interface
*
* Copyright (C) 2006 Magnus Olsen
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "framebuf.h"
VOID APIENTRY
DrvDisableDirectDraw( IN DHPDEV dhpdev)
{
PPDEV ppdev = (PPDEV)dhpdev;
ppdev->bDDInitialized = FALSE;
/* Add Clean up code here if we need it
when we shout down directx interface */
}
BOOL APIENTRY
DrvEnableDirectDraw(
IN DHPDEV dhpdev,
OUT DD_CALLBACKS *pCallBacks,
OUT DD_SURFACECALLBACKS *pSurfaceCallBacks,
OUT DD_PALETTECALLBACKS *pPaletteCallBacks)
{
PPDEV ppdev = (PPDEV)dhpdev;
if (ppdev->bDDInitialized)
{
return TRUE;
}
/* Setup pixel format */
ppdev->ddpfDisplay.dwSize = sizeof( DDPIXELFORMAT );
ppdev->ddpfDisplay.dwFourCC = 0;
ppdev->ddpfDisplay.dwRBitMask = ppdev->RedMask;
ppdev->ddpfDisplay.dwGBitMask = ppdev->GreenMask;
ppdev->ddpfDisplay.dwBBitMask = ppdev->BlueMask;
ppdev->ddpfDisplay.dwRGBBitCount=ppdev->BitsPerPixel;
ppdev->ddpfDisplay.dwRGBAlphaBitMask = 0;
ppdev->ddpfDisplay.dwFlags = DDPF_RGB;
ppdev->pvmList = NULL;
switch(ppdev->iDitherFormat)
{
case BMF_8BPP:
ppdev->ddpfDisplay.dwFlags |= DDPF_PALETTEINDEXED8;
break;
case BMF_16BPP:
switch(ppdev->RedMask)
{
case 0x7C00:
ppdev->ddpfDisplay.dwRGBAlphaBitMask = 0x8000;
break;
default:
break;
}
break;
case BMF_24BPP:
break;
case BMF_32BPP:
ppdev->ddpfDisplay.dwRGBAlphaBitMask = 0xff000000;
break;
default:
/* FIXME unknown pixel bits */
ppdev->ddpfDisplay.dwRGBBitCount=0;
break;
}
if (pCallBacks != NULL)
{
memset(pCallBacks,0,sizeof(DD_CALLBACKS));
/* FILL pCallBacks with hal stuff */
pCallBacks->dwSize = sizeof(DDHAL_DDCALLBACKS);
pCallBacks->CanCreateSurface = (PDD_CANCREATESURFACE)DdCanCreateSurface;
pCallBacks->CreateSurface = (PDD_CREATESURFACE)DdCreateSurface;
/* Fill in the HAL Callback flags */
pCallBacks->dwFlags = DDHAL_CB32_CANCREATESURFACE | DDHAL_CB32_CREATESURFACE;
}
if (pSurfaceCallBacks != NULL)
{
memset(pSurfaceCallBacks,0,sizeof(DD_SURFACECALLBACKS));
/* FILL pSurfaceCallBacks with hal stuff */
// pSurfaceCallBacks.dwSize = sizeof(DDHAL_DDSURFACECALLBACKS);
// pSurfaceCallBacks.DestroySurface = DdDestroySurface;
// pSurfaceCallBacks.Lock = DdLock;
// pSurfaceCallBacks.Blt = DdBlt;
// pSurfaceCallBacks->dwFlags = DDHAL_SURFCB32_DESTROYSURFACE | DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_BLT ;
}
if (pPaletteCallBacks != NULL)
{
memset(pPaletteCallBacks,0,sizeof(DD_PALETTECALLBACKS));
/* FILL pPaletteCallBacks with hal stuff */
/* We will not support this callback in the framebuf.dll */
}
/* Fixme fill the ppdev->dxHalInfo with the info we need */
ppdev->bDDInitialized = TRUE;
return ppdev->bDDInitialized;
}
BOOL APIENTRY
DrvGetDirectDrawInfo(
IN DHPDEV dhpdev,
OUT DD_HALINFO *pHalInfo,
OUT DWORD *pdwNumHeaps,
OUT VIDEOMEMORY *pvmList,
OUT DWORD *pdwNumFourCCCodes,
OUT DWORD *pdwFourCC)
{
PPDEV ppdev = (PPDEV)dhpdev;
LONG i;
DWORD heap = 1; /* we always alloc one heap */
BOOL bDDrawHeap = FALSE;
if (ppdev == NULL)
return FALSE;
/* check so pHalInfo, pdwNumHeaps, pdwNumFourCCCodes is not NULL
pdwFourCC and pvmList can be null
*/
if (pHalInfo == NULL)
return FALSE;
if (pdwNumHeaps == NULL)
return FALSE;
if (pdwNumFourCCCodes == NULL)
return FALSE;
/* Setup heap */
if ( (ppdev->ScreenWidth < ppdev->MemWidth) || (ppdev->ScreenHeight < ppdev->MemHeight))
{
bDDrawHeap = TRUE;
heap++;
}
ppdev->dwHeap = heap;
*pdwNumHeaps = heap;
/* We do not support other fourcc */
*pdwNumFourCCCodes = 0;
/*
check see if pvmList and pdwFourCC are frist call
or frist. Secon call we fill in pHalInfo info
*/
if(!(pvmList && pdwFourCC))
{
RtlZeroMemory(pHalInfo, sizeof(DD_HALINFO));
pHalInfo->dwSize = sizeof(DD_HALINFO);
pHalInfo->ddCaps.dwCaps = DDCAPS_BLT | DDCAPS_BLTQUEUE | DDCAPS_BLTCOLORFILL | DDCAPS_READSCANLINE |
DDCAPS_BLTSTRETCH | DDCAPS_COLORKEY | DDCAPS_CANBLTSYSMEM;
pHalInfo->ddCaps.dwFXCaps = DDFXCAPS_BLTSTRETCHY | DDFXCAPS_BLTSTRETCHX |
DDFXCAPS_BLTSTRETCHYN | DDFXCAPS_BLTSTRETCHXN |
DDFXCAPS_BLTSHRINKY | DDFXCAPS_BLTSHRINKX |
DDFXCAPS_BLTSHRINKYN | DDFXCAPS_BLTSHRINKXN |
DDFXCAPS_BLTMIRRORUPDOWN | DDFXCAPS_BLTMIRRORLEFTRIGHT;
pHalInfo->ddCaps.dwCaps2 = DDCAPS2_NONLOCALVIDMEM | DDCAPS2_NONLOCALVIDMEMCAPS;
pHalInfo->ddCaps.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP;
pHalInfo->ddCaps.dwCKeyCaps = DDCKEYCAPS_SRCBLT | DDCKEYCAPS_SRCBLTCLRSPACE;
pHalInfo->ddCaps.dwSVBCaps = DDCAPS_BLT;
pHalInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_NONLOCALVIDMEM;
/* Calc how much memmory is left on the video cards memmory */
pHalInfo->ddCaps.dwVidMemTotal = (ppdev->MemHeight - ppdev->ScreenHeight) * ppdev->ScreenDelta;
/* fill in some basic info that we need */
pHalInfo->vmiData.pvPrimary = ppdev->ScreenPtr;
pHalInfo->vmiData.dwDisplayWidth = ppdev->ScreenWidth;
pHalInfo->vmiData.dwDisplayHeight = ppdev->ScreenHeight;
pHalInfo->vmiData.lDisplayPitch = ppdev->ScreenDelta;
pHalInfo->vmiData.ddpfDisplay.dwSize = sizeof(DDPIXELFORMAT);
pHalInfo->vmiData.ddpfDisplay.dwFlags = DDPF_RGB;
pHalInfo->vmiData.ddpfDisplay.dwRGBBitCount = ppdev->BitsPerPixel;
pHalInfo->vmiData.ddpfDisplay.dwRBitMask = ppdev->RedMask;
pHalInfo->vmiData.ddpfDisplay.dwGBitMask = ppdev->GreenMask;
pHalInfo->vmiData.ddpfDisplay.dwBBitMask = ppdev->BlueMask;
pHalInfo->vmiData.dwOffscreenAlign = 4;
if ( ppdev->BitsPerPixel == 8 )
{
pHalInfo->vmiData.ddpfDisplay.dwFlags |= DDPF_PALETTEINDEXED8;
}
/* FIXME
Config the rops we do not doing that yet
for we need write the rops table
*/
for(i=0;i<DD_ROP_SPACE;i++ )
{
// pHALInfo->ddCaps.dwSVBRops[i] = rops[i];
// pHALInfo->ddCaps.dwRops[i] = rops[i];
}
}
/* Now build pvmList info */
if(pvmList)
{
ppdev->pvmList = pvmList;
if (bDDrawHeap)
{
pvmList->dwFlags = VIDMEM_ISLINEAR ;
pvmList->fpStart = ppdev->ScreenHeight * ppdev->ScreenDelta;
pvmList->fpEnd = ppdev->MemHeight * ppdev->ScreenDelta - 1;
pvmList->ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
pvmList++;
}
pvmList->fpStart = 0;
pvmList->fpEnd = (ppdev->MemHeight * ppdev->ScreenDelta) - 1;
pvmList->dwFlags = VIDMEM_ISNONLOCAL | VIDMEM_ISLINEAR | VIDMEM_ISWC;
pvmList->ddsCaps.dwCaps = DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER ;
pvmList->ddsCapsAlt.dwCaps = DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER;
pvmList = ppdev->pvmList;
}
return TRUE;
}