📄 halsurf.cpp
字号:
// If the surface is EMMA type it means it is for DVD and the display is on TV.
// So, we need to just enable Dhruva Bypass mode.
if(OverlayData.VidFormat == EMMA) {
MEM_WRITE_32(pDriverData->RegLinear, VC_VID_DHRUVA_BYPASS, 0);
MEM_WRITE_32(pDriverData->RegLinear, VC_VID_DHRUVA_BYPASS, 1);
//lpSOPData->ddRVal = DD_OK;
//return DDHAL_DRIVER_HANDLED;
}
// Begin hardware state change
BeginLoad(&VidCfg);
SetVideoPosition(&VidCfg, lpSOPData->lXPos, lpSOPData->lYPos, 0, 0, FALSE);
//jp if emma dvd playing, disable 420 format, and change vid_fmt to Y0CbY1Cr
if(OverlayData.VidFormat == EMMA) {
VidCfg &= ~VC_VCFG_420_MODE;
VidCfg &= 0xfffffff3;
VidCfg |= 0x00000008;
}
// End hardware state change (Latch data on next VSYNC)
EndLoad(VidCfg);
lpSOPData->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
} /* SetOverlayPosition32 */
DWORD WINAPI HalSetPalette( LPDDHAL_SETPALETTEDATA pd )
{
//DEBUGENTER( HalSetPalette );
/*
typedef struct _DDHAL_SETPALETTEDATA
{
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
LPDDRAWI_DDRAWPALETTE_GBL lpDDPalette; // palette to set to surface
HRESULT ddRVal; // return value
LPDDHALSURFCB_SETPALETTE SetPalette; // PRIVATE: ptr to callback
BOOL Attach; // attach this palette?
} DDHAL_SETPALETTEDATA;
*/
// Implementation
pd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
}
/********************************************************************
* updateFlipStatus
*
* checks and sees if the most recent flip has occurred
*/
HRESULT updateFlipStatus( FLATPTR fpVidMem )
{
// DEBUGENTER( upDateFlipStatus );
/*
* see if a flip has happened recently
*/
return DD_OK;
if(unflipRecord.bFlipFlag && (fpVidMem == unflipRecord.fpFlipFrom))
{
if (FlipStatus(fpVidMem - pDriverData->FbLinear))
{
unflipRecord.bFlipFlag = FALSE;
}
else
{
return DDERR_WASSTILLDRAWING;
}
}
return DD_OK;
} /* updateFlipStatus */
/****
NAME: FlipStatus
RETURN VALUE
TRUE if flip has occured, else FALSE.
****/
BOOL FlipStatus(DWORD Offset)
{
// DEBUGENTER( FlipStatus );
// DWORD ScreenOffset;
DWORD CfgData;
// BYTE reg_data;
// if(pDriverData->SysInfo1.CoreLogic >= SYSINFO1_CORE_5530)
// {
CfgData = MEM_READ_32(pDriverData->RegLinear, VC_CRCSIG_TFT_TV);
if((CfgData & 0xFFFFFF00) == 0x100)
{
return(FALSE);
}
else
{
return(TRUE);
}
// }
// else
// {
// IO_WRITE_8(CRTC_INDEX, SOFTVGA_CUR_START_LOW);
// IO_READ_8(CRTC_DATA, ®_data);
// ScreenOffset = (DWORD)reg_data;
// IO_WRITE_8(CRTC_INDEX, SOFTVGA_CUR_START_HIGH);
// IO_READ_8(CRTC_DATA, ®_data);
// ScreenOffset |= (DWORD)reg_data << 8;
// IO_WRITE_8(CRTC_INDEX, SOFTVGA_CUR_START_EXT);
// IO_READ_8(CRTC_DATA, ®_data);
// ScreenOffset |= (DWORD)reg_data << 16;
//
// if (ScreenOffset == Offset >> 2)
// {
// IO_WRITE_8(CRTC_INDEX, 0x33);
// IO_READ_8(CRTC_DATA, ®_data);
// if(reg_data & 0x40)
// {
// return(TRUE);
// }
// else
// {
// return(FALSE);
// }
// }
// }
return(TRUE);
}
/********************************************************************
* Blt32
*
* 32-bit blt routine.
*/
DWORD WINAPI HalBlt( LPDDHAL_BLTDATA pbd )
{
// DEBUGENTER( HalBlt );
//DebugBreak();
//RETAILMSG(1,(TEXT("HalBlt\r\n")));
HRESULT ddrval;
DWORD dwFlags;
DWORD dwFillColor;
DWORD dwColorKey;
DWORD dwDstOffset;
DWORD dwDstOffsetX;
DWORD dwDstOffsetY;
DWORD dwDstX;
DWORD dwDstY;
DWORD dwDstWidth;
DWORD dwDstHeight;
DWORD dwSrcOffset;
DWORD dwSrcOffsetX;
DWORD dwSrcOffsetY;
DWORD dwSrcX;
DWORD dwSrcY;
DWORD dwSrcWidth;
DWORD dwSrcHeight;
LPDDRAWI_DDRAWSURFACE_LCL srcx;
LPDDRAWI_DDRAWSURFACE_LCL dstx;
LPDDRAWI_DDRAWSURFACE_GBL src;
LPDDRAWI_DDRAWSURFACE_GBL dst;
dstx = pbd->lpDDDestSurface;
dst = dstx->lpGbl;
/*
* NOTES:
*
* Everything you need is in pdb->bltFX .
* Look at pdb->dwFlags to determine what kind of blt you are doing,
* DDBLT_xxxx are the flags.
*
* COLORKEY NOTES:
*
* ColorKey ALWAY comes in BLTFX. You don't have to look it up in
* the surface.
*/
/*
* is a flip in progress?
*/
//pbd->lpDDDestSurface->lpGbl->fpVidMem = pDriverData->FbLinear; //ullas temp
ddrval = updateFlipStatus(pbd->lpDDDestSurface->lpGbl->fpVidMem);
if( ddrval != DD_OK )
{
pbd->ddRVal = ddrval;
return DDHAL_DRIVER_HANDLED;
}
/*
* If async, then only work if bltter isn't busy
* This should probably be a little more specific to each call, but
* waiting for 16 is pretty close
*/
dwFlags = pbd->dwFlags;
if( dwFlags & DDBLT_ASYNC )
{
if( !ENOUGH_FIFO_FOR_BLT )
{
//DPF("ASYNC FAILED");
pbd->ddRVal = DDERR_WASSTILLDRAWING;
return DDHAL_DRIVER_HANDLED;
}
}
/*
* get offset, width, and height for destination
*/
dwDstOffset = dst->fpVidMem - pDriverData->FbLinear;
dwDstX = pbd->rDest.left;
dwDstY = pbd->rDest.top;
dwDstWidth = pbd->rDest.right - pbd->rDest.left;
dwDstHeight = pbd->rDest.bottom - pbd->rDest.top;
//disable cursor at this point
if((dwDstWidth == pDriverData->dwWidth) && (dwDstHeight == pDriverData->dwHeight)) {
MEM_WRITE_32(pDriverData->RegLinear, DC_UNLOCK, 0x4758); //unlock registers
unsigned long temp = MEM_READ_32(pDriverData->RegLinear, DC_GENERAL_CFG);
temp &= ~(0x00000002); //reset cursor enable bit
MEM_WRITE_32(pDriverData->RegLinear, DC_GENERAL_CFG, temp);
MEM_WRITE_32(pDriverData->RegLinear, DC_UNLOCK, 0x0); //lock registers
}
BytesToPixels(pDriverData->dwBpp, pDriverData->lPitch,
dwDstOffset, &dwDstOffsetX, &dwDstOffsetY);
// Check for linear blt
if (dst->lPitch != pDriverData->lPitch)
{
// Warning: Order is important here
dwDstHeight = ((dwDstHeight * dst->lPitch) / pDriverData->lPitch) + 1;
dwDstWidth = pDriverData->lPitch / (pDriverData->dwBpp >> 3);
}
if (dwFlags & DDBLT_ROP)
{
if (pbd->bltFX.dwROP == SRCCOPY)
{
srcx = pbd->lpDDSrcSurface;
src = srcx->lpGbl;
//src->fpVidMem = pDriverData->FbLinear; //ullas temp
dwSrcOffset = src->fpVidMem - pDriverData->FbLinear;
dwSrcX = pbd->rSrc.left;
dwSrcY = pbd->rSrc.top;
dwSrcWidth = pbd->rSrc.right - pbd->rSrc.left;
dwSrcHeight = pbd->rSrc.bottom - pbd->rSrc.top;
dwColorKey = pbd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue;
BytesToPixels(pDriverData->dwBpp, pDriverData->lPitch,
dwSrcOffset, &dwSrcOffsetX, &dwSrcOffsetY);
// Check for linear blt
if (src->lPitch != pDriverData->lPitch)
{
// Warning: Order is important here
dwSrcHeight = ((dwSrcHeight * src->lPitch) / pDriverData->lPitch) + 1;
dwSrcWidth = pDriverData->lPitch / (pDriverData->dwBpp >> 3);
}
if (dwFlags & DDBLT_KEYSRCOVERRIDE)
{
//DPF("Blt32: TransBlt from %08X %dx%d -> %08X %dx%d key=%08X", dwSrcOffset, dwSrcWidth, dwSrcHeight, dwDstOffset, dwDstWidth, dwDstHeight, dwColorKey);
//RETAILMSG(1,(TEXT("Blt32: TransBlt from %08X %dx%d -> %08X %dx%d key=%08X\r\n"), dwSrcOffset, dwSrcWidth, dwSrcHeight, dwDstOffset, dwDstWidth, dwDstHeight, dwColorKey));
//RETAILMSG(1,(TEXT("KEYSRCOVERRIDE\r\n")));
ScrToScrXBlt(dwSrcOffsetX + dwSrcX,
dwSrcOffsetY + dwSrcY,
dwDstOffsetX + dwDstX,
dwDstOffsetY + dwDstY,
dwSrcWidth, dwSrcHeight,
dwColorKey);
}
else
{
//DPF("Blt32: Blt from %08X %dx%d -> %08X %dx%d", dwSrcOffset, dwSrcWidth, dwSrcHeight, dwDstOffset, dwDstWidth, dwDstHeight);
//RETAILMSG(1,(TEXT("Blt32: Blt from %08X %dx%d -> %08X %dx%d\r\n"), dwSrcOffset, dwSrcWidth, dwSrcHeight, dwDstOffset, dwDstWidth, dwDstHeight));
#ifdef DURANGO //ScrToScrBlt
RETAILMSG(0,(TEXT("Durango ScrToScrBlt\r\n")));
gfx_set_solid_pattern(0);
gfx_set_raster_operation((unsigned char) 0xcc);
gfx_screen_to_screen_blt((unsigned short) (dwSrcOffsetX + dwSrcX), (unsigned short)(dwSrcOffsetY + dwSrcY),
(unsigned short)(dwDstOffsetX + dwDstX), (unsigned short)(dwDstOffsetY + dwDstY),
(unsigned short)dwSrcWidth, (unsigned short)dwSrcHeight);
#else
ScrToScrBlt(dwSrcOffsetX + dwSrcX,
dwSrcOffsetY + dwSrcY,
dwDstOffsetX + dwDstX,
dwDstOffsetY + dwDstY,
dwSrcWidth, dwSrcHeight);
#endif
}
}
else if (pbd->bltFX.dwROP == BLACKNESS)
{
dwFillColor = 0x00000000;
// DPF("Blt32: BLACKNESS %08X %dx%d", dwDstOffset, dwDstWidth, dwDstHeight);
FillBlt(dwDstOffsetX + dwDstX,
dwDstOffsetY + dwDstY,
dwDstWidth, dwDstHeight,
dwFillColor);
}
else if (pbd->bltFX.dwROP == WHITENESS)
{
dwFillColor = 0xFFFFFFFF;
// DPF("Blt32: WHITENESS %08X %dx%d", dwDstOffset, dwDstWidth, dwDstHeight);
FillBlt(dwDstOffsetX + dwDstX,
dwDstOffsetY + dwDstY,
dwDstWidth, dwDstHeight,
dwFillColor);
}
}
else if (dwFlags & DDBLT_COLORFILL)
{
dwFillColor = pbd->bltFX.dwFillColor;
// DPF("Blt32: fill %08X %08X %dx%d", dwFillColor, dwDstWidth, dwDstHeight);
FillBlt(dwDstOffsetX + dwDstX,
dwDstOffsetY + dwDstY,
dwDstWidth, dwDstHeight,
dwFillColor);
}
else
{
return DDHAL_DRIVER_NOTHANDLED;
}
pbd->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED;
} /* Blt32 */
/********************************************************************
* OverlayOK
*
* If vertical scale factor is less the 2x then verify overlay
* support via the following table.
*
* Res BPP Ref (Hz) GXi-133 GXi-166 GXi-200
* ----------------------------------------------------------------
* 640 x 480 8,16 all Pass Pass Pass
* 800 x 600 8,16 all Pass Pass Pass
* 1024 x 768 8 60 Pass Pass Pass
* >60 Fail Pass Pass
* 16 60 Fail Pass Pass
* >60 Fail Fail Pass
* 1280 x 1024 8 all Fail Fail Fail
*
*/
DWORD OverlayOK(DWORD Vert⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -