mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
454 lines
12 KiB
454 lines
12 KiB
/*
|
|
*
|
|
* Copyright (C) 1993, 1994 by
|
|
* DIGITAL EQUIPMENT CORPORATION, Maynard, MA.
|
|
*
|
|
* This software is furnished under a license and may be used and copied
|
|
* only in accordance with the terms of such license and with the inclusion
|
|
* of the above copyright notice. This software or any other copies there-
|
|
* of may not be provided or otherwise made available to any other person.
|
|
* No title to and ownership of the software is hereby transferred.
|
|
*
|
|
* The information in this software is subject to change without notice
|
|
* and should not be construed as a commitment by DIGITAL EQUIPMENT COR-
|
|
* PORATION.
|
|
*
|
|
* DIGITAL assumes no responsibility for the use or reliability of its
|
|
* software on equipment which is not supplied by DIGITAL.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* Module: punt.c
|
|
*
|
|
* Abstract: This module contains routines to punt back to Windows-NT for
|
|
* functions we don't handle yet.
|
|
*
|
|
* HISTORY
|
|
*
|
|
* 01-Nov-1993 Barry Tannenbaum
|
|
* Initial version. vSetSimpleMode should be called before punting to
|
|
* Windows-NT if bSimpleMode is FALSE.
|
|
*
|
|
* 01-Nov-1993 Bob Seitsinger
|
|
* '#if 0' DrvBitBlt and DrvCopyBits.
|
|
*
|
|
* 02-Nov-1993 Bill Wernsing
|
|
* '#if 0' DrvStrokePath.
|
|
*
|
|
* 4-Nov-1993 Barry Tannenbaum
|
|
* '#if 0' DrvPaint
|
|
*
|
|
* 8-Nov-1993 Barry Tannenbaum
|
|
* Use WBFLUSH instead of MEMORY_BARRIER
|
|
*
|
|
* 10-Nov-1993 Barry Tannenbaum
|
|
* Added handling for bInPuntRoutine to all of the punting routines here.
|
|
* Added DrvPlgBlt, DrvStretchBlt and DrvStorkAndFillPath so we can reset
|
|
* to simple mode *before* NT starts to write to the framebuffer.
|
|
*
|
|
* 16-NOV-1993 Bill Wernsing
|
|
* Added DrvTextOut routine
|
|
*
|
|
* 10-Dec-1993 Barry Tannenbaum
|
|
* Modifications to support sparse space. Added vPuntPutBits and
|
|
* vPuntGetBits, updated the punt routines to update punt bitmap if
|
|
* necessary, etc.
|
|
*
|
|
* 07-Jan-1994 Bob Seitsinger
|
|
* Add '#ifndef TEST_ENV' around DrvFillPath.
|
|
*
|
|
* 28-Feb-1994 Barry Tannenbaum
|
|
* Removed recursion check from vPuntGetBits and vPuntPutBits since it
|
|
* was messing up on legitimate calls.
|
|
*
|
|
* 25-May-1994 Barry Tannenbaum
|
|
* Cleaned out punted routines, since we don't need them anymore.
|
|
*
|
|
* 14-Jul-1994 Bob Seitsinger
|
|
* Add punt routines in support of 24 plane development.
|
|
*
|
|
* 08-Aug-1994 Bob Seitsinger
|
|
* Modify 24 plane punt routines to make use of existing
|
|
* punt routines found in blit, text and stroke code. Can
|
|
* do this now that we've reverted back to creating a
|
|
* device managed surface for 24 plane in the enable
|
|
* surface code.
|
|
*
|
|
* 9-Aug-1994 Barry Tannenbaum
|
|
* Setup for 24 plane support:
|
|
* - TGAMODE and TGAROP now take simple ULONGs instead of structures
|
|
* - Use default values from ppdev->ulModeTemplate & ppdev->ulRopTemplate
|
|
*
|
|
* 24-Aug-1994 Bob Seitsinger
|
|
* In vSetSimpleMode - Mask high 8 bits, if in 32bpp frame buffer mode.
|
|
*
|
|
* 21-Sep-1994 Bob Seitsinger
|
|
* No need for local variables 'mode' and 'rop' in setsimplemode. Just
|
|
* OR the bits in the macro calls. Also, make use of ppdev->
|
|
* ulPlanemaskTemplate.
|
|
*/
|
|
|
|
#include "driver.h"
|
|
#include "debug.h"
|
|
|
|
// Prototypes for routines used by 24 plane punt routines.
|
|
|
|
extern BOOL bPuntBitBlt (PPDEV ppdev,
|
|
SURFOBJ *psoTrg,
|
|
SURFOBJ *psoSrc,
|
|
SURFOBJ *psoMask,
|
|
CLIPOBJ *pco,
|
|
XLATEOBJ *pxlo,
|
|
RECTL *prclTrg,
|
|
POINTL *pptlSrc,
|
|
POINTL *pptlMask,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrush,
|
|
ROP4 rop4);
|
|
|
|
extern BOOL bPuntCopyBits (PPDEV ppdev,
|
|
SURFOBJ *psoTrg,
|
|
SURFOBJ *psoSrc,
|
|
CLIPOBJ *pco,
|
|
XLATEOBJ *pxlo,
|
|
RECTL *prclTrg,
|
|
POINTL *pptlSrc);
|
|
|
|
extern BOOL punt_paint (SURFOBJ *pso,
|
|
CLIPOBJ *pco,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrushOrg,
|
|
MIX mix);
|
|
|
|
extern BOOL punt_text (SURFOBJ *pso,
|
|
STROBJ *pstro,
|
|
FONTOBJ *pfo,
|
|
CLIPOBJ *pco,
|
|
RECTL *prclExtra,
|
|
RECTL *prclOpaque,
|
|
BRUSHOBJ *pboFore,
|
|
BRUSHOBJ *pboOpaque,
|
|
POINTL *pptlOrg,
|
|
MIX mix);
|
|
|
|
extern BOOL PuntStrokePath (SURFOBJ *pso,
|
|
PATHOBJ *ppo,
|
|
CLIPOBJ *pco,
|
|
XFORMOBJ *pxo,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrushOrg,
|
|
LINEATTRS *pla,
|
|
MIX mix);
|
|
|
|
VOID vSetSimpleMode (PPDEV ppdev)
|
|
{
|
|
|
|
DISPDBG ((1, "Reseting to Simple Mode\n"));
|
|
|
|
WBFLUSH (ppdev);
|
|
|
|
// ReSet some registers.
|
|
|
|
TGAPLANEMASK (ppdev, ppdev->ulPlanemaskTemplate);
|
|
|
|
TGAMODE (ppdev, ppdev->ulModeTemplate | TGA_MODE_SIMPLE);
|
|
|
|
TGAROP (ppdev, ppdev->ulRopTemplate | TGA_ROP_COPY);
|
|
|
|
TGAPERSISTENTPIXELMASK (ppdev, 0xffffffff);
|
|
|
|
// Now wait to make sure that the TGA has seen everything.
|
|
|
|
WBFLUSH (ppdev);
|
|
TGASYNC (ppdev);
|
|
|
|
// Note that we're in simple mode once more.
|
|
|
|
ppdev->bSimpleMode = TRUE;
|
|
}
|
|
|
|
#ifdef SPARSE_SPACE
|
|
|
|
#define STEP sizeof(ULONG)
|
|
|
|
static int punt_depth = 0;
|
|
|
|
/*
|
|
* vPuntPutBits
|
|
*
|
|
* This routine copies the portion of the punt bitmap specified to the
|
|
* framebuffer
|
|
*/
|
|
|
|
void vPuntPutBits (PPDEV ppdev, RECTL *rect)
|
|
{
|
|
PULONG src, dst;
|
|
int x, y, min_x, max_x;
|
|
PBYTE bitmap;
|
|
LONG bitmap_stride;
|
|
|
|
DISPDBG ((2, " vPuntPutBits - entry\n"));
|
|
DISPDBG ((3, " Rectangle: (%d, %d), (%d, %d)\n",
|
|
rect->left, rect->top, rect->right, rect->bottom));
|
|
|
|
// Make sure that the TGA has completed everything
|
|
|
|
TGASYNC (ppdev);
|
|
|
|
// Setup to copy data from the punt bitmap to the framebuffer
|
|
|
|
bitmap = ppdev->pPuntSurf->pvBits;
|
|
bitmap_stride = ppdev->pPuntSurf->lDelta;
|
|
|
|
min_x = rect->left & 0xfffffffc;
|
|
max_x = rect->right + STEP;
|
|
|
|
// Copy each scanline longword by longword
|
|
|
|
for (y = rect->top; y < rect->bottom; y++)
|
|
{
|
|
src = (PULONG) (bitmap + (y * bitmap_stride) + min_x);
|
|
dst = (PULONG) (ppdev->pjFrameBuffer +
|
|
(y * ppdev->lScreenStride) + min_x);
|
|
|
|
for (x = min_x; x < max_x; x += STEP)
|
|
{
|
|
WRITE_REGISTER_ULONG (dst, *src);
|
|
dst++;
|
|
src++;
|
|
}
|
|
}
|
|
|
|
DISPDBG ((2, " vPuntPutBits - exit\n"));
|
|
}
|
|
|
|
/*
|
|
* vPuntGetBits
|
|
*
|
|
* This routine copies the portion of the framebuffer specified into the punt
|
|
* bitmap
|
|
*/
|
|
|
|
void vPuntGetBits (PPDEV ppdev, RECTL *rect)
|
|
{
|
|
PULONG src, dst;
|
|
int x, y, min_x, max_x;
|
|
PBYTE bitmap;
|
|
LONG bitmap_stride;
|
|
|
|
DISPDBG ((2, " vPuntGetBits - entry\n"));
|
|
DISPDBG ((3, " Rectangle: (%d, %d), (%d, %d)\n",
|
|
rect->left, rect->top, rect->right, rect->bottom));
|
|
|
|
// Make sure that the TGA has completed everything
|
|
|
|
TGASYNC (ppdev);
|
|
|
|
// Setup to copy data from the framebuffer to the punt bitmap
|
|
|
|
bitmap = ppdev->pPuntSurf->pvBits;
|
|
bitmap_stride = ppdev->pPuntSurf->lDelta;
|
|
|
|
min_x = rect->left & 0xfffffffc;
|
|
max_x = rect->right + STEP;
|
|
|
|
// Copy each scanline longword by longword
|
|
|
|
for (y = rect->top; y < rect->bottom; y++)
|
|
{
|
|
dst = (PULONG) (bitmap + (y * bitmap_stride) + min_x);
|
|
src = (PULONG) (ppdev->pjFrameBuffer +
|
|
(y * ppdev->lScreenStride) + min_x);
|
|
|
|
for (x = min_x; x < max_x; x += STEP)
|
|
{
|
|
*dst = READ_REGISTER_ULONG (src);
|
|
dst++;
|
|
src++;
|
|
}
|
|
}
|
|
DISPDBG ((2, " vPuntGetBits - exit\n"));
|
|
}
|
|
#endif // SPARSE_SPACE
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// 24-plane punt routines.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL DrvBitBlt24 (SURFOBJ *psoTrg,
|
|
SURFOBJ *psoSrc,
|
|
SURFOBJ *psoMask,
|
|
CLIPOBJ *pco,
|
|
XLATEOBJ *pxlo,
|
|
RECTL *prclTrg,
|
|
POINTL *pptlSrc,
|
|
POINTL *pptlMask,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrush,
|
|
ROP4 rop4)
|
|
|
|
{
|
|
|
|
PPDEV ppdev;
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvBitBlt24 - Entry\n"));
|
|
|
|
if ((STYPE_DEVICE == psoTrg->iType) || (STYPE_DEVBITMAP == psoTrg->iType) || (NULL == psoSrc))
|
|
ppdev = (PPDEV)psoTrg->dhpdev;
|
|
else
|
|
ppdev = (PPDEV)psoSrc->dhpdev;
|
|
|
|
return bPuntBitBlt (ppdev, psoTrg, psoSrc, psoMask, pco, pxlo,
|
|
prclTrg, pptlSrc, pptlMask, pbo, pptlBrush, rop4);
|
|
|
|
}
|
|
|
|
BOOL DrvCopyBits24 (SURFOBJ *psoTrg,
|
|
SURFOBJ *psoSrc,
|
|
CLIPOBJ *pco,
|
|
XLATEOBJ *pxlo,
|
|
RECTL *prclTrg,
|
|
POINTL *pptlSrc)
|
|
|
|
{
|
|
|
|
PPDEV ppdev;
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvCopyBits24 - Entry\n"));
|
|
|
|
if ((STYPE_DEVICE == psoTrg->iType) || (STYPE_DEVBITMAP == psoTrg->iType) || (NULL == psoSrc))
|
|
ppdev = (PPDEV)psoTrg->dhpdev;
|
|
else
|
|
ppdev = (PPDEV)psoSrc->dhpdev;
|
|
|
|
return bPuntCopyBits (ppdev, psoTrg, psoSrc, pco, pxlo, prclTrg, pptlSrc);
|
|
|
|
}
|
|
|
|
BOOL DrvPaint24 (SURFOBJ *pso,
|
|
CLIPOBJ *pco,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrushOrg,
|
|
MIX mix)
|
|
|
|
{
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvPaint24 - Entry\n"));
|
|
|
|
return punt_paint (pso, pco, pbo, pptlBrushOrg, mix);
|
|
|
|
}
|
|
|
|
BOOL DrvStrokePath24 (SURFOBJ *pso,
|
|
PATHOBJ *ppo,
|
|
CLIPOBJ *pco,
|
|
XFORMOBJ *pxo,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrushOrg,
|
|
LINEATTRS *pla,
|
|
MIX mix)
|
|
|
|
{
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvStrokePath24 - Entry\n"));
|
|
|
|
return PuntStrokePath (pso, ppo, pco, pxo, pbo,
|
|
pptlBrushOrg, pla, mix);
|
|
|
|
}
|
|
|
|
BOOL DrvFillPath24 (SURFOBJ *pso,
|
|
PATHOBJ *ppo,
|
|
CLIPOBJ *pco,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrushOrg,
|
|
MIX mix,
|
|
FLONG flOptions)
|
|
|
|
{
|
|
|
|
#ifdef TEST_ENV
|
|
DISPDBG ((0, "DrvFillPath24 punted\n"));
|
|
return FALSE;
|
|
#else
|
|
BOOL status;
|
|
BOOL old_bInPuntRoutine;
|
|
PPDEV ppdev = (PPDEV) pso->dhpdev;
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvFillPath24 - Entry\n"));
|
|
|
|
// Force back to simple mode and wait for memory to flush
|
|
|
|
if (! ppdev->bSimpleMode)
|
|
vSetSimpleMode (ppdev);
|
|
|
|
// Punt the call
|
|
|
|
PUNT_GET_BITS (ppdev, CHOOSE_RECT (ppdev, pco));
|
|
|
|
old_bInPuntRoutine = ppdev->bInPuntRoutine;
|
|
ppdev->bInPuntRoutine = TRUE;
|
|
|
|
status = EngFillPath (ppdev->pPuntSurf, ppo, pco, pbo, pptlBrushOrg, mix, flOptions);
|
|
|
|
ppdev->bInPuntRoutine = old_bInPuntRoutine;
|
|
|
|
PUNT_PUT_BITS (status, ppdev, CHOOSE_RECT (ppdev, pco));
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvFillPath24 - Exit\n"));
|
|
|
|
return status;
|
|
#endif
|
|
}
|
|
|
|
BOOL DrvTextOut24 (SURFOBJ *pso, // Surface we're writing to
|
|
STROBJ *pstro, // List of strings to write
|
|
FONTOBJ *pfo, // Font we're using
|
|
CLIPOBJ *pco, // Clip list for this string
|
|
RECTL *prclExtra, // Extra rectangles to be displayed
|
|
RECTL *prclOpaque, // Opaque rectangle
|
|
BRUSHOBJ *pboFore, // Foreground brush (text bits)
|
|
BRUSHOBJ *pboOpaque, // Background brush
|
|
POINTL *pptlOrg, // Brush origin
|
|
MIX mix)
|
|
|
|
{
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvTextOut24 - Entry\n"));
|
|
|
|
return punt_text (pso, pstro, pfo, pco, prclExtra, prclOpaque,
|
|
pboFore, pboOpaque, pptlOrg, mix);
|
|
|
|
}
|
|
|
|
ULONG DrvSaveScreenBits24 (SURFOBJ *pso,
|
|
ULONG iMode,
|
|
ULONG iIdent,
|
|
RECTL *prcl)
|
|
|
|
{
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvSaveScreenBits24 - Entry\n"));
|
|
|
|
switch (iMode)
|
|
{
|
|
case SS_SAVE:
|
|
case SS_RESTORE:
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
case SS_FREE:
|
|
{
|
|
return TRUE;
|
|
}
|
|
};
|
|
|
|
DISPDBG ((1, "TGA.DLL!DrvSaveScreenBits24 - Exit\n"));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|