📄 blt.cpp
字号:
//-----------------------------------------------------------------------
//
// 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.
// Copyright (c) 1999 Microsoft Corporation
//
// written by: ESG Solution Center Munich
//
// Module Name: blt.cpp
//
// abstract: Windows CE display driver for C&T 69000
// C&T 69000 blit functions
//
//-----------------------------------------------------------------------
#include "precomp.h"
//
// handy shortcut for acceleration functions
//
#define FUNCNAME(basename) \
((SCODE (GPE::*)(struct GPEBltParms *))Emulator::Emulated##basename)
//-----------------------------------------------------------------------
//
// CT69000::DbgBltParms
//
// provide some debugging information of the blit data
//
//-----------------------------------------------------------------------
#if DEBUG
VOID
CT69000::DbgBltParms( INT iDebugLevel, GPEBltParms *pBltParms)
{
DEBUGMSG(iDebugLevel,
(TEXT("--BltParms rop4: 0x%04x flags %08lx\r\n"),
pBltParms->rop4, pBltParms->bltFlags));
if (pBltParms->bltFlags & (BLT_TRANSPARENT|BLT_STRETCH))
{
DEBUGMSG(iDebugLevel,(TEXT(" bltFlags -- ")));
if (pBltParms->bltFlags & BLT_TRANSPARENT)
{
DEBUGMSG(iDebugLevel,(TEXT("BLT_TRANSPARENT")));
}
if (pBltParms->bltFlags & BLT_STRETCH)
{
DEBUGMSG(iDebugLevel,(TEXT("BLT_STRETCH")));
}
DEBUGMSG(iDebugLevel,(TEXT("\r\n")));
}
if (pBltParms->solidColor != -1)
{
DEBUGMSG(iDebugLevel,
(TEXT(" solidColor(0x%06x)\r\n"),pBltParms->solidColor));
}
DEBUGMSG(iDebugLevel,
(TEXT(" Dest Format: %d, Dest Rect: t:%d,l:%d,b:%d,r:%d Dest GPESurf 0x%08x (%d)\r\n"),
(int) pBltParms->pDst->Format(), pBltParms->prclDst->top,
pBltParms->prclDst->left, pBltParms->prclDst->bottom,
pBltParms->prclDst->right, pBltParms->pDst, pBltParms->pDst->InVideoMemory()));
if (pBltParms->prclSrc && pBltParms->pSrc)
{
DEBUGMSG(iDebugLevel,
(TEXT(" Src format: %d, Src Rect: %d,%d,%d,%d Src GPESurf 0x%08x (%d)\r\n"),
(int) pBltParms->pSrc->Format(), pBltParms->prclSrc->top,
pBltParms->prclSrc->left, pBltParms->prclSrc->bottom,
pBltParms->prclSrc->right, pBltParms->pSrc, pBltParms->pSrc->InVideoMemory()));
}
if (pBltParms->prclMask && pBltParms->pMask)
{
DEBUGMSG(iDebugLevel,
(TEXT(" mask format: %d, stride %ld Mask Rect: %d,%d,%d,%d Mask GPESurf 0x%08x (%d)\r\n"),
(int) pBltParms->pMask->Format(), pBltParms->pMask->Stride(), pBltParms->prclMask->top,
pBltParms->prclMask->left, pBltParms->prclMask->bottom,
pBltParms->prclMask->right, pBltParms->pMask, pBltParms->pMask->InVideoMemory()));
}
if (pBltParms->pptlBrush && pBltParms->pBrush)
{
DEBUGMSG(iDebugLevel,
(TEXT(" brush format: %d, Brush Point: %d,%d Mask GPESurf 0x%08x (%d)\r\n"),
(int) pBltParms->pBrush->Format(), pBltParms->pptlBrush->x,
pBltParms->pptlBrush->y, pBltParms->pBrush, pBltParms->pBrush->InVideoMemory()));
}
}
#endif
//-----------------------------------------------------------------------
//
// CT69000::BltPrepare
//
// this function is called whenever gpe is about to blit. We can decide
// here if the hardware is able to do the blit and provide an
// accelerated blt function if possible. Otherwise we should return the
// pointer to the emulated blit function.
//
//-----------------------------------------------------------------------
SCODE
CT69000::BltPrepare(GPEBltParms *pBltParms)
{
GPESurf *pSrc=pBltParms->pSrc;
GPESurf *pDst=pBltParms->pDst;
DEBUGMSG(CT69K_ZONE_FUNCTION, (TEXT("CT69000::BltPrepare\r\n")));
//
// default: always emulate blits
//
pBltParms->pBlt = EmulatedBlt; // catch all
//
// for testing the cursor can alter m_iBltEmulation to switch
// between different acceleration levels without rebooting the
// Windows CE image.
//
#if CURSORDEBUG
if (m_bBltEmulation==0)
#endif
//
// this hardware can only accelerate in video memory
//
if (pDst->InVideoMemory())
{
switch( pBltParms->rop4 )
{
//
// fills fully described by the rop
//
case 0xaaaa: // DSTCOPY
case 0x5555: // DSTINVERT (not D)
case 0xFFFF: // WHITENESS
case 0x0000: // BLACKNESS
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedFill) - dst only\r\n")));
pBltParms->pBlt = (SCODE (GPE::*) (struct GPEBltParms *))AcceleratedFill;
return S_OK;
//
// fills with no source, but with a solid color or pattern
//
case 0x0505: // not (D or P)
case 0x0a0a: // D and (not P)
case 0x0f0f: // not P
case 0x5050: // P and (not D)
case 0x5a5a: // D xor P (PATINVERT)
case 0x5f5f: // not (D and P)
case 0xA0A0: // D and P
case 0xa5a5: // not (P xor D)
case 0xafaf: // D or (not P)
case 0xF0F0: // PATCOPY
case 0xf5f5: // P or (not D)
case 0xfafa: // D or P
if (pBltParms->solidColor != -1)
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedFill) - COLOR(%06lx)\r\n"),
pBltParms->solidColor));
pBltParms->pBlt = (SCODE (GPE::*) (struct GPEBltParms *)) AcceleratedFill;
return S_OK;
} else
{
/*
if (pBltParms->pLookup || pBltParms->pConvert)
{
//
// we cannot do a color conversion in hardware for patterns
//
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("--couldn't handle pLookup or pConversion")));
break;
}
if(!pBltParms->pBrush ||
pBltParms->pBrush->Width() != 0x0008 ||
pBltParms->pBrush->Height() != 0x0008)
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("--couldn't handle non 8x8 brush size")));
break;
}
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedPatternFill)\r\n")));
pBltParms->pBlt =
(SCODE (GPE::*) (struct GPEBltParms *)) AcceleratedPatternFill;
return S_OK;
*/
}
break;
case 0xAAF0: // Special PATCOPY rop for text output -- fill where mask is set.
// Not a pattern brush?
if (pBltParms->solidColor != -1)
{
if ( pBltParms->pMask->Format() == gpe1Bpp)
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedTextOut1bpp) - 0xAAF0\r\n")));
pBltParms->pBlt =
(SCODE (GPE::*) (struct GPEBltParms *)) AcceleratedTextOut1bpp;
return S_OK;
}
}
break;
}
//
// here we check for all other blits with a source from videomemory
//
if (pSrc &&
pSrc->InVideoMemory() &&
!(pBltParms->bltFlags & (BLT_STRETCH))
)
{
switch( pBltParms->rop4 )
{
case 0x1111: // not (D or S)
case 0x2222: // D and (not S)
case 0x3333: // not S
case 0x4444: // S and (not D)
case 0x6666: // D xor S
case 0x7777: // not (D and S)
case 0x8888: // D and S
case 0x9999: // not (D xor S)
case 0xbbbb: // D or (not S)
case 0xCCCC: // SRCCOPY (S)
case 0xdddd: // S or (not D)
case 0xeeee: // D or S
if (pBltParms->bltFlags & BLT_TRANSPARENT)
{
DEBUGMSG( CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedTransparentSrcCopyBlt) - SRC+DST(%04x)\r\n"), pBltParms->rop4));
pBltParms->pBlt =
(SCODE (GPE::*) (struct GPEBltParms *))AcceleratedTransparentSrcCopyBlt;
}
else
{
DEBUGMSG( CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedSrcCopyBlt) - SRC+DST(%04x)\r\n"), pBltParms->rop4));
pBltParms->pBlt =
(SCODE (GPE::*) (struct GPEBltParms *))AcceleratedSrcCopyBlt;
}
return S_OK;
default:
//
// we can handle ALL rops blits without a mask!
//
if (!pBltParms->pMask)
{
if(pBltParms->pBrush)
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("--no brush support for now")));
break;
}
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt(AcceleratedPatSrcDstBlt) - SRC+DST+PAT(%04x)\r\n"), pBltParms->rop4));
pBltParms->pBlt =
(SCODE (GPE::*) (struct GPEBltParms *))AcceleratedPatSrcDstBlt;
return S_OK;
}
break;
}
}
DEBUGMSG( CT69K_ZONE_BLTLO,(TEXT("CT69000::Blt(unknown)\r\n")));
DBGBLTPARMS( CT69K_ZONE_BLTLO, pBltParms);
} else
{
DEBUGMSG(CT69K_ZONE_BLTLO,(TEXT("--dst is not in video memory\r\n")));
DBGBLTPARMS( CT69K_ZONE_BLTLO, pBltParms);
}
#if CURSORDEBUG
if (m_bBltEmulation>1)
return S_OK;
#endif
if( pDst->InVideoMemory() )
{
// If we have a pending blt and now attempt a software operation using
// video memory, the pipeline must be flushed.
WaitForNotBusy();
}
//
// see if we can emulate an 8bpp blt
//
if ( pDst->Format() == gpe8Bpp &&
!((pBltParms->bltFlags & (BLT_TRANSPARENT | BLT_STRETCH)) ||
pBltParms->pLookup ||
pBltParms->pConvert)
)
{
//
// list of emulated blits for 8bit emulation
//
switch( pBltParms->rop4 )
{
case 0x0000: // BLACKNESS
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - BLACKNESS\r\n")));
pBltParms->solidColor = 0;
pBltParms->pBlt = FUNCNAME(BltFill08);
return S_OK;
case 0xFFFF: // WHITENESS
DEBUGMSG(CT69K_ZONE_BLTHI, (TEXT("CT69000::Blt - WHITENESS\r\n")));
pBltParms->solidColor = 0x00ffffff;
pBltParms->pBlt = FUNCNAME(BltFill08);
return S_OK;
case 0xF0F0: // PATCOPY
if( pBltParms->solidColor != -1 )
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt - PATCOPY - solid brush\r\n")));
pBltParms->pBlt = FUNCNAME(BltFill08);
return S_OK;
}
break;
case 0x5A5A: // PATINVERT
if( pBltParms->solidColor != -1 )
{
DEBUGMSG(CT69K_ZONE_BLTHI,
(TEXT("CT69000::Blt - PATINVERT - solid brush\r\n")));
pBltParms->pBlt = FUNCNAME(BltPatInvert08);
return S_OK;
}
break;
case 0x5555: // DSTINVERT
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - DSTINVERT\r\n")));
pBltParms->pBlt = FUNCNAME(BltDstInvert08);
return S_OK;
case 0xCCCC: // SRCCOPY
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - SRCCOPY\r\n")));
pBltParms->pBlt = FUNCNAME(BltSrcCopy0808);
return S_OK;
case 0x8888: // SRCAND
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - SRCAND\r\n")));
pBltParms->pBlt = FUNCNAME(BltSrcAnd0808);
return S_OK;
case 0xEEEE: // SRCPAINT
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - SRCPAINT\r\n")));
pBltParms->pBlt = FUNCNAME(BltSrcPaint0808);
return S_OK;
case 0x6666: // SRCINVERT
DEBUGMSG(CT69K_ZONE_BLTHI,(TEXT("CT69000::Blt - SRCINVERT\r\n")));
pBltParms->pBlt = FUNCNAME(BltSrcInvert0808);
return S_OK;
case 0xAAF0: // Special PATCOPY rop for text output -- fill where mask is 1.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -