From eb32aa038bc20044d3a6359611ba91a674bbe03f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Herv=C3=A9=20Poussineau?= Date: Sun, 21 Oct 2007 18:35:19 +0000 Subject: [PATCH] [FORMATTING] General cleanup (indentation, headers...). No code change svn path=/trunk/; revision=29748 --- .../drivers/video/displays/vga/main/enable.c | 773 ++++----- .../video/displays/vga/objects/bitblt.c | 838 ++++----- .../video/displays/vga/objects/copybits.c | 59 +- .../video/displays/vga/objects/lineto.c | 690 ++++---- .../video/displays/vga/objects/offscreen.c | 239 ++- .../video/displays/vga/objects/paint.c | 388 +++-- .../video/displays/vga/objects/pointer.c | 579 +++---- .../video/displays/vga/objects/screen.c | 321 ++-- .../video/displays/vga/objects/transblt.c | 45 +- reactos/drivers/video/displays/vga/vgaddi.def | 7 - .../video/displays/vga/vgavideo/vgavideo.c | 1530 ++++++++--------- 11 files changed, 2711 insertions(+), 2758 deletions(-) diff --git a/reactos/drivers/video/displays/vga/main/enable.c b/reactos/drivers/video/displays/vga/main/enable.c index 66d2175b61f..e5b0b12c4d1 100644 --- a/reactos/drivers/video/displays/vga/main/enable.c +++ b/reactos/drivers/video/displays/vga/main/enable.c @@ -1,5 +1,9 @@ /* - * entry.c + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/main/enable.c + * PURPOSE: + * PROGRAMMERS: */ #include "../vgaddi.h" @@ -11,145 +15,145 @@ static BOOL VGAInitialized = FALSE; -DRVFN FuncList[] = +static DRVFN FuncList[] = { - /* Required Display driver fuctions */ - {INDEX_DrvAssertMode, (PFN) DrvAssertMode}, - {INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV}, - {INDEX_DrvCopyBits, (PFN) DrvCopyBits}, - {INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV}, - {INDEX_DrvDisableSurface, (PFN) DrvDisableSurface}, - {INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV}, - {INDEX_DrvEnableSurface, (PFN) DrvEnableSurface}, - {INDEX_DrvGetModes, (PFN) DrvGetModes}, - {INDEX_DrvLineTo, (PFN) DrvLineTo}, - {INDEX_DrvPaint, (PFN) DrvPaint}, - {INDEX_DrvBitBlt, (PFN) DrvBitBlt}, - {INDEX_DrvTransparentBlt, (PFN) DrvTransparentBlt}, - {INDEX_DrvMovePointer, (PFN) DrvMovePointer}, - {INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape}, + /* Required Display driver fuctions */ + {INDEX_DrvAssertMode, (PFN) DrvAssertMode}, + {INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV}, + {INDEX_DrvCopyBits, (PFN) DrvCopyBits}, + {INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV}, + {INDEX_DrvDisableSurface, (PFN) DrvDisableSurface}, + {INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV}, + {INDEX_DrvEnableSurface, (PFN) DrvEnableSurface}, + {INDEX_DrvGetModes, (PFN) DrvGetModes}, + {INDEX_DrvLineTo, (PFN) DrvLineTo}, + {INDEX_DrvPaint, (PFN) DrvPaint}, + {INDEX_DrvBitBlt, (PFN) DrvBitBlt}, + {INDEX_DrvTransparentBlt, (PFN) DrvTransparentBlt}, + {INDEX_DrvMovePointer, (PFN) DrvMovePointer}, + {INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape}, #if 0 - /* Optional Display driver functions */ - {INDEX_, (PFN) }, - {INDEX_DescribePixelFormat, (PFN) VGADDIDescribePixelFormat}, - {INDEX_DrvDitherColor, (PFN) VGADDIDitherColor}, - {INDEX_DrvFillPath, (PFN) VGADDIFillPath}, - {INDEX_DrvGetTrueTypeFile, (PFN) VGADDIGetTrueTypeFile}, - {INDEX_DrvLoadFontFile, (PFN) VGADDILoadFontFile}, - {INDEX_DrvQueryFont, (PFN) VGADDIQueryFont}, - {INDEX_DrvQueryFontCaps, (PFN) VGADDIQueryFontCaps}, - {INDEX_DrvQueryFontData, (PFN) VGADDIQueryFontData}, - {INDEX_DrvQueryFontFile, (PFN) VGADDIQueryFontFile}, - {INDEX_DrvQueryFontTree, (PFN) VGADDIQueryFontTree}, - {INDEX_DrvQueryTrueTypeOutline, (PFN) VGADDIQueryTrueTypeOutline}, - {INDEX_DrvQueryTrueTypeTable, (PFN) VGADDIQueryTrueTypeTable}, - {INDEX_DrvRealizeBrush, (PFN) VGADDIRealizeBrush}, - {INDEX_DrvResetPDEV, (PFN) VGADDIResetPDEV}, - {INDEX_DrvSetPalette, (PFN) VGADDISetPalette}, - {INDEX_DrvSetPixelFormat, (PFN) VGADDISetPixelFormat}, - {INDEX_DrvStretchBlt, (PFN) VGADDIStretchBlt}, - {INDEX_DrvStrokePath, (PFN) VGADDIStrokePath}, - {INDEX_DrvSwapBuffers, (PFN) VGADDISwapBuffers}, - {INDEX_DrvTextOut, (PFN) VGADDITextOut}, - {INDEX_DrvUnloadFontFile, (PFN) VGADDIUnloadFontFile}, + /* Optional Display driver functions */ + {INDEX_, }, + {INDEX_DescribePixelFormat, (PFN) VGADDIDescribePixelFormat}, + {INDEX_DrvDitherColor, (PFN) VGADDIDitherColor}, + {INDEX_DrvFillPath, (PFN) VGADDIFillPath}, + {INDEX_DrvGetTrueTypeFile, (PFN) VGADDIGetTrueTypeFile}, + {INDEX_DrvLoadFontFile, (PFN) VGADDILoadFontFile}, + {INDEX_DrvQueryFont, (PFN) VGADDIQueryFont}, + {INDEX_DrvQueryFontCaps, (PFN) VGADDIQueryFontCaps}, + {INDEX_DrvQueryFontData, (PFN) VGADDIQueryFontData}, + {INDEX_DrvQueryFontFile, (PFN) VGADDIQueryFontFile}, + {INDEX_DrvQueryFontTree, (PFN) VGADDIQueryFontTree}, + {INDEX_DrvQueryTrueTypeOutline, (PFN) VGADDIQueryTrueTypeOutline}, + {INDEX_DrvQueryTrueTypeTable, (PFN) VGADDIQueryTrueTypeTable}, + {INDEX_DrvRealizeBrush, (PFN) VGADDIRealizeBrush}, + {INDEX_DrvResetPDEV, (PFN) VGADDIResetPDEV}, + {INDEX_DrvSetPalette, (PFN) VGADDISetPalette}, + {INDEX_DrvSetPixelFormat, (PFN) VGADDISetPixelFormat}, + {INDEX_DrvStretchBlt, (PFN) VGADDIStretchBlt}, + {INDEX_DrvStrokePath, (PFN) VGADDIStrokePath}, + {INDEX_DrvSwapBuffers, (PFN) VGADDISwapBuffers}, + {INDEX_DrvTextOut, (PFN) VGADDITextOut}, + {INDEX_DrvUnloadFontFile, (PFN) VGADDIUnloadFontFile}, #endif }; -GDIINFO gaulCap = { - GDI_DRIVER_VERSION, - DT_RASDISPLAY, // ulTechnology - 0, // ulHorzSize - 0, // ulVertSize - 0, // ulHorzRes (filled in at initialization) - 0, // ulVertRes (filled in at initialization) - 4, // cBitsPixel - 1, // cPlanes - 16, // ulNumColors - 0, // flRaster (DDI reserved field) +static GDIINFO gaulCap = { + GDI_DRIVER_VERSION, + DT_RASDISPLAY, // ulTechnology + 0, // ulHorzSize + 0, // ulVertSize + 0, // ulHorzRes (filled in at initialization) + 0, // ulVertRes (filled in at initialization) + 4, // cBitsPixel + 1, // cPlanes + 16, // ulNumColors + 0, // flRaster (DDI reserved field) - 96, // ulLogPixelsX (must be set to 96 according to MSDN) - 96, // ulLogPixelsY (must be set to 96 according to MSDN) + 96, // ulLogPixelsX (must be set to 96 according to MSDN) + 96, // ulLogPixelsY (must be set to 96 according to MSDN) - TC_RA_ABLE | TC_SCROLLBLT, // flTextCaps + TC_RA_ABLE | TC_SCROLLBLT, // flTextCaps - 6, // ulDACRed - 6, // ulDACGree - 6, // ulDACBlue + 6, // ulDACRed + 6, // ulDACGree + 6, // ulDACBlue - 0x0024, // ulAspectX (one-to-one aspect ratio) - 0x0024, // ulAspectY - 0x0033, // ulAspectXY + 0x0024, // ulAspectX (one-to-one aspect ratio) + 0x0024, // ulAspectY + 0x0033, // ulAspectXY - 1, // xStyleStep - 1, // yStyleSte; - 3, // denStyleStep + 1, // xStyleStep + 1, // yStyleSte; + 3, // denStyleStep - { 0, 0 }, // ptlPhysOffset - { 0, 0 }, // szlPhysSize + { 0, 0 }, // ptlPhysOffset + { 0, 0 }, // szlPhysSize - 0, // ulNumPalReg (win3.1 16 color drivers say 0 too) + 0, // ulNumPalReg (win3.1 16 color drivers say 0 too) // These fields are for halftone initialization. - { // ciDevice, ColorInfo - { 6700, 3300, 0 }, // Red - { 2100, 7100, 0 }, // Green - { 1400, 800, 0 }, // Blue - { 1750, 3950, 0 }, // Cyan - { 4050, 2050, 0 }, // Magenta - { 4400, 5200, 0 }, // Yellow - { 3127, 3290, 0 }, // AlignmentWhite - 20000, // RedGamma - 20000, // GreenGamma - 20000, // BlueGamma - 0, 0, 0, 0, 0, 0 - }, + { // ciDevice, ColorInfo + { 6700, 3300, 0 }, // Red + { 2100, 7100, 0 }, // Green + { 1400, 800, 0 }, // Blue + { 1750, 3950, 0 }, // Cyan + { 4050, 2050, 0 }, // Magenta + { 4400, 5200, 0 }, // Yellow + { 3127, 3290, 0 }, // AlignmentWhite + 20000, // RedGamma + 20000, // GreenGamma + 20000, // BlueGamma + 0, 0, 0, 0, 0, 0 + }, - 0, // ulDevicePelsDPI - PRIMARY_ORDER_CBA, // ulPrimaryOrder - HT_PATSIZE_4x4_M, // ulHTPatternSize - HT_FORMAT_4BPP_IRGB, // ulHTOutputFormat - HT_FLAG_ADDITIVE_PRIMS, // flHTFlags + 0, // ulDevicePelsDPI + PRIMARY_ORDER_CBA, // ulPrimaryOrder + HT_PATSIZE_4x4_M, // ulHTPatternSize + HT_FORMAT_4BPP_IRGB, // ulHTOutputFormat + HT_FLAG_ADDITIVE_PRIMS, // flHTFlags - 0, // ulVRefresh - 8, // ulBltAlignment - 0, // ulPanningHorzRes - 0, // ulPanningVertRes -}; + 0, // ulVRefresh + 8, // ulBltAlignment + 0, // ulPanningHorzRes + 0, // ulPanningVertRes + }; // Palette for VGA typedef struct _VGALOGPALETTE { - USHORT ident; - USHORT NumEntries; - PALETTEENTRY PaletteEntry[16]; + USHORT ident; + USHORT NumEntries; + PALETTEENTRY PaletteEntry[16]; } VGALOGPALETTE; const VGALOGPALETTE VGApalette = { -0x400, // driver version -16, // num entries -{ - { 0x00, 0x00, 0x00, 0x00 }, // 0 - { 0x80, 0x00, 0x00, 0x00 }, // 1 - { 0x00, 0x80, 0x00, 0x00 }, // 2 - { 0x80, 0x80, 0x00, 0x00 }, // 3 - { 0x00, 0x00, 0x80, 0x00 }, // 4 - { 0x80, 0x00, 0x80, 0x00 }, // 5 - { 0x00, 0x80, 0x80, 0x00 }, // 6 - { 0x80, 0x80, 0x80, 0x00 }, // 7 - { 0xc0, 0xc0, 0xc0, 0x00 }, // 8 - { 0xff, 0x00, 0x00, 0x00 }, // 9 - { 0x00, 0xff, 0x00, 0x00 }, // 10 - { 0xff, 0xff, 0x00, 0x00 }, // 11 - { 0x00, 0x00, 0xff, 0x00 }, // 12 - { 0xff, 0x00, 0xff, 0x00 }, // 13 - { 0x00, 0xff, 0xff, 0x00 }, // 14 - { 0xff, 0xff, 0xff, 0x00 } // 15 -} + 0x400, // driver version + 16, // num entries + { + { 0x00, 0x00, 0x00, 0x00 }, // 0 + { 0x80, 0x00, 0x00, 0x00 }, // 1 + { 0x00, 0x80, 0x00, 0x00 }, // 2 + { 0x80, 0x80, 0x00, 0x00 }, // 3 + { 0x00, 0x00, 0x80, 0x00 }, // 4 + { 0x80, 0x00, 0x80, 0x00 }, // 5 + { 0x00, 0x80, 0x80, 0x00 }, // 6 + { 0x80, 0x80, 0x80, 0x00 }, // 7 + { 0xc0, 0xc0, 0xc0, 0x00 }, // 8 + { 0xff, 0x00, 0x00, 0x00 }, // 9 + { 0x00, 0xff, 0x00, 0x00 }, // 10 + { 0xff, 0xff, 0x00, 0x00 }, // 11 + { 0x00, 0x00, 0xff, 0x00 }, // 12 + { 0xff, 0x00, 0xff, 0x00 }, // 13 + { 0x00, 0xff, 0xff, 0x00 }, // 14 + { 0xff, 0xff, 0xff, 0x00 } // 15 + } }; // Devinfo structure passed back to the engine in DrvEnablePDEV @@ -160,37 +164,36 @@ const VGALOGPALETTE VGApalette = DEVINFO devinfoVGA = { - (GCAPS_OPAQUERECT | GCAPS_HORIZSTRIKE | GCAPS_ALTERNATEFILL | GCAPS_MONO_DITHER | GCAPS_COLOR_DITHER | - GCAPS_WINDINGFILL | GCAPS_DITHERONREALIZE - ), // Graphics capabilities + (GCAPS_OPAQUERECT | GCAPS_HORIZSTRIKE | GCAPS_ALTERNATEFILL | GCAPS_MONO_DITHER | GCAPS_COLOR_DITHER | + GCAPS_WINDINGFILL | GCAPS_DITHERONREALIZE + ), // Graphics capabilities - SYSTM_LOGFONT, // Default font description - HELVE_LOGFONT, // ANSI variable font description - COURI_LOGFONT, // ANSI fixed font description - 0, // Count of device fonts - BMF_4BPP, // preferred DIB format - 8, // Width of color dither - 8, // Height of color dither - 0 // Default palette to use for this device + SYSTM_LOGFONT, // Default font description + HELVE_LOGFONT, // ANSI variable font description + COURI_LOGFONT, // ANSI fixed font description + 0, // Count of device fonts + BMF_4BPP, // preferred DIB format + 8, // Width of color dither + 8, // Height of color dither + 0 // Default palette to use for this device }; - BOOL APIENTRY DrvEnableDriver(IN ULONG EngineVersion, - IN ULONG SizeOfDED, - OUT PDRVENABLEDATA DriveEnableData) + IN ULONG SizeOfDED, + OUT PDRVENABLEDATA DriveEnableData) { -/* EngDebugPrint("VGADDI", "DrvEnableDriver called...\n", 0); */ + /* EngDebugPrint("VGADDI", "DrvEnableDriver called...\n", 0); */ - vgaPreCalc(); + vgaPreCalc(); - VGADDI_InitializeOffScreenMem((640 * 480) >> 3, 65536 - ((640 * 480) >> 3)); + VGADDI_InitializeOffScreenMem((SCREEN_X * SCREEN_Y) >> 3, 65536 - ((SCREEN_X * SCREEN_Y) >> 3)); - DriveEnableData->pdrvfn = FuncList; - DriveEnableData->c = sizeof(FuncList) / sizeof(DRVFN); - DriveEnableData->iDriverVersion = DDI_DRIVER_VERSION_NT4; + DriveEnableData->pdrvfn = FuncList; + DriveEnableData->c = sizeof(FuncList) / sizeof(DRVFN); + DriveEnableData->iDriverVersion = DDI_DRIVER_VERSION_NT4; - return TRUE; + return TRUE; } // DrvDisableDriver @@ -204,7 +207,7 @@ DrvEnableDriver(IN ULONG EngineVersion, VOID APIENTRY DrvDisableDriver(VOID) { - return; + return; } // ----------------------------------------------- Driver Implementation @@ -232,47 +235,43 @@ DrvDisableDriver(VOID) DHPDEV APIENTRY DrvEnablePDEV(IN DEVMODEW *DM, - IN LPWSTR LogAddress, - IN ULONG PatternCount, - OUT HSURF *SurfPatterns, - IN ULONG GDIInfoSize, - OUT ULONG *GDIInfo, - IN ULONG DevInfoSize, - OUT DEVINFO *DevInfo, - IN HDEV Dev, - IN LPWSTR DeviceName, - IN HANDLE Driver) + IN LPWSTR LogAddress, + IN ULONG PatternCount, + OUT HSURF *SurfPatterns, + IN ULONG GDIInfoSize, + OUT ULONG *GDIInfo, + IN ULONG DevInfoSize, + OUT DEVINFO *DevInfo, + IN HDEV Dev, + IN LPWSTR DeviceName, + IN HANDLE Driver) { - PPDEV PDev; + PPDEV PDev; - PDev = EngAllocMem(FL_ZERO_MEMORY, sizeof(PDEV), ALLOC_TAG); - if (PDev == NULL) + PDev = EngAllocMem(FL_ZERO_MEMORY, sizeof(PDEV), ALLOC_TAG); + if (PDev == NULL) { - EngDebugPrint(DBG_PREFIX, "EngAllocMem failed for PDEV\n", 0); - return(NULL); + EngDebugPrint(DBG_PREFIX, "EngAllocMem failed for PDEV\n", 0); + return NULL; } - PDev->KMDriver = Driver; - DPRINT( "PDev: %x, Driver: %x\n", PDev, PDev->KMDriver ); + PDev->KMDriver = Driver; + DPRINT( "PDev: %x, Driver: %x\n", PDev, PDev->KMDriver ); - gaulCap.ulHorzRes = 640; - gaulCap.ulVertRes = 480; - if (sizeof(GDIINFO) < GDIInfoSize) - { - GDIInfoSize = sizeof(GDIINFO); - } - memcpy(GDIInfo, &gaulCap, GDIInfoSize); - DM->dmBitsPerPel = gaulCap.cBitsPixel * gaulCap.cPlanes; - DM->dmPelsWidth = gaulCap.ulHorzRes; - DM->dmPelsHeight = gaulCap.ulVertRes; + gaulCap.ulHorzRes = SCREEN_X; + gaulCap.ulVertRes = SCREEN_Y; + if (sizeof(GDIINFO) < GDIInfoSize) + GDIInfoSize = sizeof(GDIINFO); + memcpy(GDIInfo, &gaulCap, GDIInfoSize); + DM->dmBitsPerPel = gaulCap.cBitsPixel * gaulCap.cPlanes; + DM->dmPelsWidth = gaulCap.ulHorzRes; + DM->dmPelsHeight = gaulCap.ulVertRes; - devinfoVGA.hpalDefault = EngCreatePalette(PAL_INDEXED, 16, (ULONG *) VGApalette.PaletteEntry, 0, 0, 0); - if (sizeof(DEVINFO) < DevInfoSize) - { - DevInfoSize = sizeof(DEVINFO); - } - memcpy(DevInfo, &devinfoVGA, DevInfoSize); + devinfoVGA.hpalDefault = EngCreatePalette(PAL_INDEXED, 16, (ULONG *) VGApalette.PaletteEntry, 0, 0, 0); + if (sizeof(DEVINFO) < DevInfoSize) + DevInfoSize = sizeof(DEVINFO); + memcpy(DevInfo, &devinfoVGA, DevInfoSize); - return (DHPDEV) PDev; + return (DHPDEV) PDev; } @@ -283,319 +282,301 @@ DrvEnablePDEV(IN DEVMODEW *DM, VOID APIENTRY DrvCompletePDEV(IN DHPDEV PDev, - IN HDEV Dev) + IN HDEV Dev) { - ((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC + ((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC } BOOL APIENTRY DrvAssertMode(IN DHPDEV DPev, - IN BOOL Enable) + IN BOOL Enable) { - PPDEV ppdev = (PPDEV)DPev; - ULONG returnedDataLength; + PPDEV ppdev = (PPDEV)DPev; + ULONG returnedDataLength; - if(Enable==TRUE) - { - // Reenable our graphics mode - - if (!InitPointer(ppdev)) + if(Enable==TRUE) { - // Failed to set pointer - return FALSE; - } + /* Reenable our graphics mode */ + if (!InitPointer(ppdev)) + { + /* Failed to set pointer */ + return FALSE; + } - if (!VGAInitialized) - { - if (!InitVGA(ppdev, FALSE)) - { - // Failed to initialize the VGA - return FALSE; - } - VGAInitialized = TRUE; + if (!VGAInitialized) + { + if (!InitVGA(ppdev, FALSE)) + { + /* Failed to initialize the VGA */ + return FALSE; + } + VGAInitialized = TRUE; } - } else { - // Go back to last known mode - DPRINT( "ppdev: %x, KMDriver: %x", ppdev, ppdev->KMDriver ); - if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength)) - { - // Failed to go back to mode - return FALSE; } - VGAInitialized = FALSE; - } - return TRUE; + else + { + /* Go back to last known mode */ + DPRINT( "ppdev: %x, KMDriver: %x", ppdev, ppdev->KMDriver ); + if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength)) + { + /* Failed to go back to mode */ + return FALSE; + } + VGAInitialized = FALSE; + } + return TRUE; } VOID APIENTRY DrvDisablePDEV(IN DHPDEV PDev) { - PPDEV ppdev = (PPDEV)PDev; + PPDEV ppdev = (PPDEV)PDev; - // EngDeletePalette(devinfoVGA.hpalDefault); - if (ppdev->pjPreallocSSBBuffer != NULL) - { - EngFreeMem(ppdev->pjPreallocSSBBuffer); - } + /* EngDeletePalette(devinfoVGA.hpalDefault); */ + if (ppdev->pjPreallocSSBBuffer) + EngFreeMem(ppdev->pjPreallocSSBBuffer); - if (ppdev->pucDIB4ToVGAConvBuffer != NULL) - { - EngFreeMem(ppdev->pucDIB4ToVGAConvBuffer); - } - DPRINT( "Freeing PDEV\n" ); - EngFreeMem(PDev); + if (ppdev->pucDIB4ToVGAConvBuffer) + EngFreeMem(ppdev->pucDIB4ToVGAConvBuffer); + + DPRINT("Freeing PDEV\n"); + EngFreeMem(PDev); } VOID APIENTRY DrvDisableSurface(IN DHPDEV PDev) { - PPDEV ppdev = (PPDEV)PDev; - PDEVSURF pdsurf = ppdev->AssociatedSurf; - CHECKPOINT; - DPRINT( "KMDriver: %x\n", ppdev->KMDriver ); - DeinitVGA(ppdev); - // EngFreeMem(pdsurf->BankSelectInfo); - CHECKPOINT; - if (pdsurf->BankInfo != NULL) { - EngFreeMem(pdsurf->BankInfo); - } - CHECKPOINT; - if (pdsurf->BankInfo2RW != NULL) { - EngFreeMem(pdsurf->BankInfo2RW); - } - CHECKPOINT; - if (pdsurf->BankBufferPlane0 != NULL) { - EngFreeMem(pdsurf->BankBufferPlane0); - } - CHECKPOINT; - if (ppdev->pPointerAttributes != NULL) { - EngFreeMem(ppdev->pPointerAttributes); - } - CHECKPOINT; - // free any pending saved screen bit blocks + PPDEV ppdev = (PPDEV)PDev; + PDEVSURF pdsurf = ppdev->AssociatedSurf; + + DPRINT("KMDriver: %x\n", ppdev->KMDriver); + DeinitVGA(ppdev); + /* EngFreeMem(pdsurf->BankSelectInfo); */ + + if (pdsurf->BankInfo != NULL) + EngFreeMem(pdsurf->BankInfo); + if (pdsurf->BankInfo2RW != NULL) + EngFreeMem(pdsurf->BankInfo2RW); + if (pdsurf->BankBufferPlane0 != NULL) + EngFreeMem(pdsurf->BankBufferPlane0); + if (ppdev->pPointerAttributes != NULL) + EngFreeMem(ppdev->pPointerAttributes); + + /* free any pending saved screen bit blocks */ #if 0 - pSSB = pdsurf->ssbList; - while (pSSB != (PSAVED_SCREEN_BITS) NULL) { + pSSB = pdsurf->ssbList; + while (pSSB != (PSAVED_SCREEN_BITS) NULL) + { + /* Point to the next saved screen bits block */ + pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB; - // Point to the next saved screen bits block - pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB; - - // Free the current block - EngFreeMem(pSSB); - pSSB = pSSBNext; + /* Free the current block */ + EngFreeMem(pSSB); + pSSB = pSSBNext; } #endif - EngDeleteSurface((HSURF) ppdev->SurfHandle); - // EngFreeMem(pdsurf); // free the surface + EngDeleteSurface((HSURF) ppdev->SurfHandle); + /* EngFreeMem(pdsurf); */ /* free the surface */ } static VOID -InitSavedBits(PPDEV ppdev) +InitSavedBits(IN PPDEV ppdev) { - if (!(ppdev->fl & DRIVER_OFFSCREEN_REFRESHED)) - { - return; - } + if (!(ppdev->fl & DRIVER_OFFSCREEN_REFRESHED)) + return; - // set up rect to right of visible screen - ppdev->SavedBitsRight.left = ppdev->sizeSurf.cx; - ppdev->SavedBitsRight.top = 0; - ppdev->SavedBitsRight.right = ppdev->sizeMem.cx-PLANAR_PELS_PER_CPU_ADDRESS; - ppdev->SavedBitsRight.bottom = ppdev->sizeSurf.cy; - - if ((ppdev->SavedBitsRight.right <= ppdev->SavedBitsRight.left) || - (ppdev->SavedBitsRight.bottom <= ppdev->SavedBitsRight.top)) - { - ppdev->SavedBitsRight.left = 0; + /* set up rect to right of visible screen */ + ppdev->SavedBitsRight.left = ppdev->sizeSurf.cx; ppdev->SavedBitsRight.top = 0; - ppdev->SavedBitsRight.right = 0; - ppdev->SavedBitsRight.bottom = 0; - } + ppdev->SavedBitsRight.right = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS; + ppdev->SavedBitsRight.bottom = ppdev->sizeSurf.cy; - // set up rect below visible screen - ppdev->SavedBitsBottom.left = 0; - ppdev->SavedBitsBottom.top = ppdev->sizeSurf.cy; - ppdev->SavedBitsBottom.right = ppdev->sizeMem.cx-PLANAR_PELS_PER_CPU_ADDRESS; - ppdev->SavedBitsBottom.bottom = ppdev->sizeMem.cy - ppdev->NumScansUsedByPointer; + if ((ppdev->SavedBitsRight.right <= ppdev->SavedBitsRight.left) || + (ppdev->SavedBitsRight.bottom <= ppdev->SavedBitsRight.top)) + { + ppdev->SavedBitsRight.left = 0; + ppdev->SavedBitsRight.top = 0; + ppdev->SavedBitsRight.right = 0; + ppdev->SavedBitsRight.bottom = 0; + } - if ((ppdev->SavedBitsBottom.right <= ppdev->SavedBitsBottom.left) || - (ppdev->SavedBitsBottom.bottom <= ppdev->SavedBitsBottom.top)) - { + /* set up rect below visible screen */ ppdev->SavedBitsBottom.left = 0; - ppdev->SavedBitsBottom.top = 0; - ppdev->SavedBitsBottom.right = 0; - ppdev->SavedBitsBottom.bottom = 0; - } + ppdev->SavedBitsBottom.top = ppdev->sizeSurf.cy; + ppdev->SavedBitsBottom.right = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS; + ppdev->SavedBitsBottom.bottom = ppdev->sizeMem.cy - ppdev->NumScansUsedByPointer; - ppdev->BitsSaved = FALSE; + if ((ppdev->SavedBitsBottom.right <= ppdev->SavedBitsBottom.left) || + (ppdev->SavedBitsBottom.bottom <= ppdev->SavedBitsBottom.top)) + { + ppdev->SavedBitsBottom.left = 0; + ppdev->SavedBitsBottom.top = 0; + ppdev->SavedBitsBottom.right = 0; + ppdev->SavedBitsBottom.bottom = 0; + } - return; + ppdev->BitsSaved = FALSE; } HSURF APIENTRY DrvEnableSurface(IN DHPDEV PDev) { - PPDEV ppdev = (PPDEV)PDev; - PDEVSURF pdsurf; - DHSURF dhsurf; - HSURF hsurf; + PPDEV ppdev = (PPDEV)PDev; + PDEVSURF pdsurf; + DHSURF dhsurf; + HSURF hsurf; - DPRINT("DrvEnableSurface() called\n"); + DPRINT("DrvEnableSurface() called\n"); - // Initialize the VGA - if (!VGAInitialized) + /* Initialize the VGA */ + if (!VGAInitialized) { - if (!InitVGA(ppdev, TRUE)) - { - goto error_done; - } - VGAInitialized = TRUE; + if (!InitVGA(ppdev, TRUE)) + goto error_done; + VGAInitialized = TRUE; } - // dhsurf is of type DEVSURF, which is the drivers specialized surface type - dhsurf = (DHSURF)EngAllocMem(0, sizeof(DEVSURF), ALLOC_TAG); - if (dhsurf == (DHSURF) 0) - { - goto error_done; - } + /* dhsurf is of type DEVSURF, which is the drivers specialized surface type */ + dhsurf = (DHSURF)EngAllocMem(0, sizeof(DEVSURF), ALLOC_TAG); + if (dhsurf == (DHSURF) 0) + goto error_done; - pdsurf = (PDEVSURF) dhsurf; - pdsurf->ident = DEVSURF_IDENT; - pdsurf->flSurf = 0; - pdsurf->Format = BMF_PHYSDEVICE; - pdsurf->jReserved1 = 0; - pdsurf->jReserved2 = 0; - pdsurf->ppdev = ppdev; - pdsurf->sizeSurf.cx = ppdev->sizeSurf.cx; - pdsurf->sizeSurf.cy = ppdev->sizeSurf.cy; - pdsurf->NextPlane = 0; - pdsurf->Scan0 = ppdev->fbScreen; - pdsurf->BitmapStart = ppdev->fbScreen; - pdsurf->StartBmp = ppdev->fbScreen; - pdsurf->BankInfo = NULL; - pdsurf->BankInfo2RW = NULL; - pdsurf->BankBufferPlane0 = NULL; + pdsurf = (PDEVSURF) dhsurf; + pdsurf->ident = DEVSURF_IDENT; + pdsurf->flSurf = 0; + pdsurf->Format = BMF_PHYSDEVICE; + pdsurf->jReserved1 = 0; + pdsurf->jReserved2 = 0; + pdsurf->ppdev = ppdev; + pdsurf->sizeSurf.cx = ppdev->sizeSurf.cx; + pdsurf->sizeSurf.cy = ppdev->sizeSurf.cy; + pdsurf->NextPlane = 0; + pdsurf->Scan0 = ppdev->fbScreen; + pdsurf->BitmapStart = ppdev->fbScreen; + pdsurf->StartBmp = ppdev->fbScreen; + pdsurf->BankInfo = NULL; + pdsurf->BankInfo2RW = NULL; + pdsurf->BankBufferPlane0 = NULL; -/* pdsurf->Conv = &ConvertBuffer[0]; */ +/* pdsurf->Conv = &ConvertBuffer[0]; */ - if (!InitPointer(ppdev)) { - DbgPrint("DrvEnablePDEV failed bInitPointer\n"); - goto error_clean; - } + if (!InitPointer(ppdev)) + { + DPRINT1("DrvEnablePDEV failed bInitPointer\n"); + goto error_clean; + } -/* if (!SetUpBanking(pdsurf, ppdev)) { - DISPDBG((0, "DrvEnablePDEV failed SetUpBanking\n")); - goto error_clean; - } BANKING CODE UNIMPLEMENTED */ +/* if (!SetUpBanking(pdsurf, ppdev)) + { + DPRINT1("DrvEnablePDEV failed SetUpBanking\n"); + goto error_clean; + } BANKING CODE UNIMPLEMENTED */ - if ((hsurf = EngCreateDeviceSurface(dhsurf, ppdev->sizeSurf, BMF_4BPP)) == - (HSURF)0) - { - // Call to EngCreateDeviceSurface failed - EngDebugPrint("VGADDI:", "EngCreateDeviceSurface call failed\n", 0); - goto error_clean; - } + if ((hsurf = EngCreateDeviceSurface(dhsurf, ppdev->sizeSurf, BMF_4BPP)) == + (HSURF)0) + { + /* Call to EngCreateDeviceSurface failed */ + DPRINT("EngCreateDeviceSurface call failed\n"); + goto error_clean; + } - InitSavedBits(ppdev); + InitSavedBits(ppdev); - if (EngAssociateSurface(hsurf, ppdev->GDIDevHandle, HOOK_BITBLT | HOOK_PAINT | HOOK_LINETO | HOOK_COPYBITS | - HOOK_TRANSPARENTBLT)) - { -/* EngDebugPrint("VGADDI:", "Successfully associated surface\n", 0); */ - ppdev->SurfHandle = hsurf; - ppdev->AssociatedSurf = pdsurf; + if (EngAssociateSurface(hsurf, ppdev->GDIDevHandle, HOOK_BITBLT | HOOK_PAINT | HOOK_LINETO | HOOK_COPYBITS | + HOOK_TRANSPARENTBLT)) + { + DPRINT("Successfully associated surface\n"); + ppdev->SurfHandle = hsurf; + ppdev->AssociatedSurf = pdsurf; - // Set up an empty saved screen block list - pdsurf->ssbList = NULL; + /* Set up an empty saved screen block list */ + pdsurf->ssbList = NULL; - return(hsurf); - } - DPRINT( "EngAssociateSurface() failed\n" ); - EngDeleteSurface(hsurf); + return hsurf; + } + DPRINT("EngAssociateSurface() failed\n"); + EngDeleteSurface(hsurf); error_clean: - EngFreeMem(dhsurf); + EngFreeMem(dhsurf); error_done: - return((HSURF)0); + return (HSURF)0; } ULONG APIENTRY DrvGetModes(IN HANDLE Driver, - IN ULONG DataSize, - OUT PDEVMODEW DM) + IN ULONG DataSize, + OUT PDEVMODEW DM) { - DWORD NumModes; - DWORD ModeSize; - DWORD OutputSize; - DWORD OutputModes = DataSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); - PVIDEO_MODE_INFORMATION VideoModeInformation, VideoTemp; + DWORD NumModes; + DWORD ModeSize; + DWORD OutputSize; + DWORD OutputModes = DataSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); + PVIDEO_MODE_INFORMATION VideoModeInformation, VideoTemp; - NumModes = getAvailableModes(Driver, - (PVIDEO_MODE_INFORMATION *) &VideoModeInformation, - &ModeSize); + NumModes = getAvailableModes(Driver, + (PVIDEO_MODE_INFORMATION *) &VideoModeInformation, + &ModeSize); - if (NumModes == 0) - { - return 0; - } + if (NumModes == 0) + return 0; - if (DM == NULL) - { - OutputSize = NumModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); - } else { - - OutputSize=0; - VideoTemp = VideoModeInformation; - - do + if (DM == NULL) { - if (VideoTemp->Length != 0) - { - if (OutputModes == 0) + OutputSize = NumModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); + } + else + { + OutputSize=0; + VideoTemp = VideoModeInformation; + + do { - break; - } + if (VideoTemp->Length != 0) + { + if (OutputModes == 0) + break; - memset(DM, 0, sizeof(DEVMODEW)); - memcpy(DM->dmDeviceName, DLL_NAME, sizeof(DLL_NAME)); + memset(DM, 0, sizeof(DEVMODEW)); + memcpy(DM->dmDeviceName, DLL_NAME, sizeof(DLL_NAME)); - DM->dmSpecVersion = DM_SPECVERSION; - DM->dmDriverVersion = DM_SPECVERSION; - DM->dmSize = sizeof(DEVMODEW); - DM->dmDriverExtra = DRIVER_EXTRA_SIZE; - DM->dmBitsPerPel = VideoTemp->NumberOfPlanes * - VideoTemp->BitsPerPlane; - DM->dmPelsWidth = VideoTemp->VisScreenWidth; - DM->dmPelsHeight = VideoTemp->VisScreenHeight; - DM->dmDisplayFrequency = VideoTemp->Frequency; - DM->dmDisplayFlags = 0; + DM->dmSpecVersion = DM_SPECVERSION; + DM->dmDriverVersion = DM_SPECVERSION; + DM->dmSize = sizeof(DEVMODEW); + DM->dmDriverExtra = DRIVER_EXTRA_SIZE; + DM->dmBitsPerPel = VideoTemp->NumberOfPlanes * + VideoTemp->BitsPerPlane; + DM->dmPelsWidth = VideoTemp->VisScreenWidth; + DM->dmPelsHeight = VideoTemp->VisScreenHeight; + DM->dmDisplayFrequency = VideoTemp->Frequency; + DM->dmDisplayFlags = 0; - DM->dmFields = DM_BITSPERPEL | - DM_PELSWIDTH | - DM_PELSHEIGHT | - DM_DISPLAYFREQUENCY | - DM_DISPLAYFLAGS ; + DM->dmFields = DM_BITSPERPEL | + DM_PELSWIDTH | + DM_PELSHEIGHT | + DM_DISPLAYFREQUENCY | + DM_DISPLAYFLAGS ; - // next DEVMODE entry - OutputModes--; + /* next DEVMODE entry */ + OutputModes--; - DM = (PDEVMODEW) ( ((ULONG)DM) + sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); + DM = (PDEVMODEW) ( ((ULONG)DM) + sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); - OutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); - } + OutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); + } - VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + ModeSize); + VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + ModeSize); - } while (--NumModes); - } - return OutputSize; + } while (--NumModes); + } + return OutputSize; } /* EOF */ diff --git a/reactos/drivers/video/displays/vga/objects/bitblt.c b/reactos/drivers/video/displays/vga/objects/bitblt.c index 9fef2c47967..27fa5ec01fa 100644 --- a/reactos/drivers/video/displays/vga/objects/bitblt.c +++ b/reactos/drivers/video/displays/vga/objects/bitblt.c @@ -1,3 +1,11 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/bitblt.c + * PURPOSE: + * PROGRAMMERS: + */ + #include "../vgaddi.h" #include "../vgavideo/vgavideo.h" #include "brush.h" @@ -18,465 +26,485 @@ typedef BOOL (APIENTRY *PBLTRECTFUNC)(SURFOBJ* OutputObj, POINTL* BrushOrigin, ROP4 Rop4); -static BOOL FASTCALL VGADDI_IntersectRect(RECTL* prcDst, RECTL* prcSrc1, RECTL* prcSrc2) +static BOOL FASTCALL VGADDI_IntersectRect( + OUT RECTL* prcDst, + IN RECTL* prcSrc1, + IN RECTL* prcSrc2) { - static const RECTL rclEmpty = { 0, 0, 0, 0 }; + static const RECTL rclEmpty = { 0, 0, 0, 0 }; - prcDst->left = max(prcSrc1->left, prcSrc2->left); - prcDst->right = min(prcSrc1->right, prcSrc2->right); + prcDst->left = max(prcSrc1->left, prcSrc2->left); + prcDst->right = min(prcSrc1->right, prcSrc2->right); - if (prcDst->left < prcDst->right) - { - prcDst->top = max(prcSrc1->top, prcSrc2->top); - prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); + if (prcDst->left < prcDst->right) + { + prcDst->top = max(prcSrc1->top, prcSrc2->top); + prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); - if (prcDst->top < prcDst->bottom) return(TRUE); - } + if (prcDst->top < prcDst->bottom) return(TRUE); + } - *prcDst = rclEmpty; + *prcDst = rclEmpty; - return(FALSE); + return FALSE; } void DIB_BltToVGA_Fixed(int x, int y, int w, int h, void *b, int Source_lDelta, int mod); BOOL -DIBtoVGA(SURFOBJ *Dest, SURFOBJ *Source, XLATEOBJ *ColorTranslation, - RECTL *DestRect, POINTL *SourcePoint) +DIBtoVGA( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint) { - LONG dx, dy; + LONG dx, dy; - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; - if (NULL == ColorTranslation || 0 != (ColorTranslation->flXlate & XO_TRIVIAL)) + if (NULL == ColorTranslation || 0 != (ColorTranslation->flXlate & XO_TRIVIAL)) { - DIB_BltToVGA(DestRect->left, DestRect->top, dx, dy, - (PVOID)((ULONG_PTR)Source->pvScan0 + SourcePoint->y * Source->lDelta + (SourcePoint->x >> 1)), - Source->lDelta, SourcePoint->x % 2); + DIB_BltToVGA(DestRect->left, DestRect->top, dx, dy, + (PVOID)((ULONG_PTR)Source->pvScan0 + SourcePoint->y * Source->lDelta + (SourcePoint->x >> 1)), + Source->lDelta, SourcePoint->x % 2); } - else + else { - /* Perform color translation */ - DIB_BltToVGAWithXlate(DestRect->left, DestRect->top, dx, dy, - (PVOID)((ULONG_PTR)Source->pvScan0 + SourcePoint->y * Source->lDelta + (SourcePoint->x >> 1)), - Source->lDelta, ColorTranslation); + /* Perform color translation */ + DIB_BltToVGAWithXlate(DestRect->left, DestRect->top, dx, dy, + (PVOID)((ULONG_PTR)Source->pvScan0 + SourcePoint->y * Source->lDelta + (SourcePoint->x >> 1)), + Source->lDelta, ColorTranslation); } - return FALSE; + return FALSE; } BOOL -VGAtoDIB(SURFOBJ *Dest, SURFOBJ *Source, XLATEOBJ *ColorTranslation, - RECTL *DestRect, POINTL *SourcePoint) +VGAtoDIB( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint) { - LONG i, j, dx, dy; - BYTE *GDIpos, *initial; + LONG i, j, dx, dy; + UCHAR *GDIpos, *initial; - // Used by the temporary DFB - DEVSURF DestDevSurf; + /* Used by the temporary DFB */ + DEVSURF DestDevSurf; - // FIXME: Optimize to retrieve entire bytes at a time (see /display/vgavideo/vgavideo.c:vgaGetByte) + /* FIXME: Optimize to retrieve entire bytes at a time (see ../vgavideo/vgavideo.c:vgaGetByte) */ - GDIpos = Dest->pvScan0 /* + (DestRect->top * Dest->lDelta) + (DestRect->left >> 1) */ ; - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; + GDIpos = Dest->pvScan0 /* + (DestRect->top * Dest->lDelta) + (DestRect->left >> 1) */ ; + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; - if(ColorTranslation == NULL) - { - // Prepare a Dest Dev Target and copy from the DFB to the DIB - DestDevSurf.NextScan = Dest->lDelta; - DestDevSurf.StartBmp = Dest->pvScan0; - - DIB_BltFromVGA(SourcePoint->x, SourcePoint->y, dx, dy, Dest->pvScan0, Dest->lDelta); - - } else { - // Color translation - for(j=SourcePoint->y; jy+dy; j++) + if (ColorTranslation == NULL) { - initial = GDIpos; - for(i=SourcePoint->x; ix+dx; i++) - { - *GDIpos = XLATEOBJ_iXlate(ColorTranslation, vgaGetPixel(i, j)); - GDIpos+=1; - } - GDIpos = initial + Dest->lDelta; + /* Prepare a Dest Dev Target and copy from the DFB to the DIB */ + DestDevSurf.NextScan = Dest->lDelta; + DestDevSurf.StartBmp = Dest->pvScan0; + + DIB_BltFromVGA(SourcePoint->x, SourcePoint->y, dx, dy, Dest->pvScan0, Dest->lDelta); + } - } - return FALSE; + else + { + /* Color translation */ + for (j = SourcePoint->y; j < SourcePoint->y + dy; j++) + { + initial = GDIpos; + for (i = SourcePoint->x; i < SourcePoint->x + dx; i++) + { + *GDIpos = XLATEOBJ_iXlate(ColorTranslation, vgaGetPixel(i, j)); + GDIpos++; + } + GDIpos = initial + Dest->lDelta; + } + } + return FALSE; } BOOL -DFBtoVGA(SURFOBJ *Dest, SURFOBJ *Source, XLATEOBJ *ColorTranslation, - RECTL *DestRect, POINTL *SourcePoint) +DFBtoVGA( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint) { - return FALSE; - // Do DFBs need color translation?? + /* Do DFBs need color translation?? */ + return FALSE; } BOOL -VGAtoDFB(SURFOBJ *Dest, SURFOBJ *Source, XLATEOBJ *ColorTranslation, - RECTL *DestRect, POINTL *SourcePoint) +VGAtoDFB( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint) { - return FALSE; - // Do DFBs need color translation?? + /* Do DFBs need color translation?? */ + return FALSE; } BOOL -VGAtoVGA(SURFOBJ *Dest, SURFOBJ *Source, XLATEOBJ *ColorTranslation, - RECTL *DestRect, POINTL *SourcePoint) +VGAtoVGA( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint) { - LONG i, i2, j, dx, dy, alterx, altery; - //LARGE_INTEGER Start, End; // for performance measurement only - static char buf[640]; + LONG i, i2, j, dx, dy, alterx, altery; + static char buf[SCREEN_X]; - // Calculate deltas + /* Calculate deltas */ + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; + alterx = DestRect->left - SourcePoint->x; + altery = DestRect->top - SourcePoint->y; - alterx = DestRect->left - SourcePoint->x; - altery = DestRect->top - SourcePoint->y; + i = SourcePoint->x; + i2 = i + alterx; - //KeQueryTickCount ( &Start ); + if (SourcePoint->y >= DestRect->top) + { + for (j = SourcePoint->y; j < SourcePoint->y + dy; j++) + { + LONG j2 = j + altery; + vgaReadScan ( i, j, dx, buf ); + vgaWriteScan ( i2, j2, dx, buf ); + } + } + else + { + for(j = (SourcePoint->y + dy - 1); j >= SourcePoint->y; j--) + { + LONG j2 = j + altery; + vgaReadScan ( i, j, dx, buf ); + vgaWriteScan ( i2, j2, dx, buf ); + } + } - i = SourcePoint->x; - i2 = i + alterx; - - if (SourcePoint->y >= DestRect->top) - { - for(j=SourcePoint->y; jy+dy; j++) - { - LONG j2 = j + altery; - vgaReadScan ( i, j, dx, buf ); - vgaWriteScan ( i2, j2, dx, buf ); - } - } - else - { - for(j=(SourcePoint->y+dy-1); j>=SourcePoint->y; j--) - { - LONG j2 = j + altery; - vgaReadScan ( i, j, dx, buf ); - vgaWriteScan ( i2, j2, dx, buf ); - } - } - - //KeQueryTickCount ( &End ); - //DbgPrint ( "VgaBitBlt timing: %lu\n", (ULONG)(End.QuadPart-Start.QuadPart) ); - - return TRUE; + return TRUE; } BOOL APIENTRY -VGADDI_BltBrush(SURFOBJ* Dest, SURFOBJ* Source, SURFOBJ* MaskSurf, - XLATEOBJ* ColorTranslation, RECTL* DestRect, - POINTL* SourcePoint, POINTL* MaskPoint, - BRUSHOBJ* Brush, POINTL* BrushPoint, ROP4 Rop4) +VGADDI_BltBrush( + IN SURFOBJ* Dest, + IN SURFOBJ* Source, + IN SURFOBJ* MaskSurf, + IN XLATEOBJ* ColorTranslation, + IN RECTL* DestRect, + IN POINTL* SourcePoint, + IN POINTL* MaskPoint, + IN BRUSHOBJ* Brush, + IN POINTL* BrushPoint, + IN ROP4 Rop4) { - UCHAR SolidColor = 0; - LONG Left; - LONG Length; - PUCHAR Video; - UCHAR Mask; - INT i, j; - ULONG RasterOp = VGA_NORMAL; + UCHAR SolidColor = 0; + LONG Left; + LONG Length; + PUCHAR Video; + UCHAR Mask; + INT i, j; + ULONG RasterOp = VGA_NORMAL; - /* Punt brush blts to non-device surfaces. */ - if (Dest->iType != STYPE_DEVICE) + /* Punt brush blts to non-device surfaces. */ + if (Dest->iType != STYPE_DEVICE) + return FALSE; + + /* Punt pattern fills. */ + if ((GET_OPINDEX_FROM_ROP4(Rop4) == GET_OPINDEX_FROM_ROP3(PATCOPY) + || GET_OPINDEX_FROM_ROP4(Rop4) == GET_OPINDEX_FROM_ROP3(PATINVERT)) && + Brush->iSolidColor == 0xFFFFFFFF) { - return(FALSE); - } - - /* Punt pattern fills. */ - if ((GET_OPINDEX_FROM_ROP4(Rop4) == GET_OPINDEX_FROM_ROP3(PATCOPY) - || GET_OPINDEX_FROM_ROP4(Rop4) == GET_OPINDEX_FROM_ROP3(PATINVERT)) && - Brush->iSolidColor == 0xFFFFFFFF) - { - return(FALSE); - } - - /* Get the brush colour. */ - switch (GET_OPINDEX_FROM_ROP4(Rop4)) - { - case GET_OPINDEX_FROM_ROP3(PATCOPY): SolidColor = Brush->iSolidColor; break; - case GET_OPINDEX_FROM_ROP3(PATINVERT): SolidColor = Brush->iSolidColor; RasterOp = VGA_XOR; break; - case GET_OPINDEX_FROM_ROP3(WHITENESS): SolidColor = 0xF; break; - case GET_OPINDEX_FROM_ROP3(BLACKNESS): SolidColor = 0x0; break; - case GET_OPINDEX_FROM_ROP3(DSTINVERT): SolidColor = 0xF; RasterOp = VGA_XOR; break; - } - - /* Select write mode 3. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x03); - - /* Setup set/reset register. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x00); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, (UCHAR)SolidColor); - - /* Enable writes to all pixels. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); - - /* Set up data rotate. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, RasterOp); - - /* Fill any pixels on the left which don't fall into a full row of eight. */ - if ((DestRect->left % 8) != 0) - { - /* Disable writes to pixels outside of the destination rectangle. */ - Mask = (1 << (8 - (DestRect->left % 8))) - 1; - if ((DestRect->right - DestRect->left) < (8 - (DestRect->left % 8))) - { - Mask &= ~((1 << (8 - (DestRect->right % 8))) - 1); - } - - /* Write the same color to each pixel. */ - Video = (PUCHAR)vidmem + DestRect->top * 80 + (DestRect->left >> 3); - for (i = DestRect->top; i < DestRect->bottom; i++, Video+=80) - { - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, Mask); - } - - /* Have we finished. */ - if ((DestRect->right - DestRect->left) < (8 - (DestRect->left % 8))) - { - /* Restore write mode 2. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - - /* Set up data rotate. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - - return TRUE; - } - } - - /* Fill any whole rows of eight pixels. */ - Left = (DestRect->left + 7) & ~0x7; - Length = (DestRect->right >> 3) - (Left >> 3); - for (i = DestRect->top; i < DestRect->bottom; i++) - { - Video = (PUCHAR)vidmem + i * 80 + (Left >> 3); - for (j = 0; j < Length; j++, Video++) - { -#if 0 - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, 0xFF); -#else - char volatile Temp = *Video; - Temp |= 0; - *Video = 0xFF; -#endif - } - } - - /* Fill any pixels on the right which don't fall into a complete row. */ - if ((DestRect->right % 8) != 0) - { - /* Disable writes to pixels outside the destination rectangle. */ - Mask = ~((1 << (8 - (DestRect->right % 8))) - 1); - - Video = (PUCHAR)vidmem + DestRect->top * 80 + (DestRect->right >> 3); - for (i = DestRect->top; i < DestRect->bottom; i++, Video+=80) - { - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, Mask); - } - } - - /* Restore write mode 2. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - - /* Set up data rotate. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - - return TRUE; -} - -BOOL APIENTRY -VGADDI_BltSrc(SURFOBJ* Dest, SURFOBJ* Source, SURFOBJ* Mask, - XLATEOBJ* ColorTranslation, RECTL* DestRect, POINTL* SourcePoint, - POINTL* MaskOrigin, BRUSHOBJ* Brush, POINTL* BrushOrigin, ROP4 Rop4) -{ - PFN_VGABlt BltOperation; - ULONG SourceType; - - SourceType = Source->iType; - - if (SourceType == STYPE_BITMAP && Dest->iType == STYPE_DEVICE) - { - BltOperation = DIBtoVGA; - } - else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_BITMAP) - { - BltOperation = VGAtoDIB; - } - else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_DEVICE) - { - BltOperation = VGAtoVGA; - } - else if (SourceType == STYPE_DEVBITMAP && Dest->iType == STYPE_DEVICE) - { - BltOperation = DFBtoVGA; - } - else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_DEVBITMAP) - { - BltOperation = VGAtoDFB; - } - else - { - /* Punt blts not involving a device or a device-bitmap. */ - return(FALSE); - } - - BltOperation(Dest, Source, ColorTranslation, DestRect, SourcePoint); - return(TRUE); -} - -BOOL APIENTRY -VGADDI_BltMask(SURFOBJ* Dest, SURFOBJ* Source, SURFOBJ* Mask, - XLATEOBJ* ColorTranslation, RECTL* DestRect, - POINTL* SourcePoint, POINTL* MaskPoint, BRUSHOBJ* Brush, - POINTL* BrushPoint, ROP4 Rop4) -{ - LONG i, j, dx, dy, c8; - BYTE *tMask, *lMask; - - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; - - if (ColorTranslation == NULL) - { - if (Mask != NULL) - { - tMask = Mask->pvScan0; - for (j=0; jleft + i, DestRect->top + j, Brush->iSolidColor); - } - c8++; - if(c8 == 8) { lMask++; c8=0; } - } - tMask += Mask->lDelta; - } - } - } - return TRUE; -} - -BOOL APIENTRY -DrvBitBlt(SURFOBJ *Dest, - SURFOBJ *Source, - SURFOBJ *Mask, - CLIPOBJ *Clip, - XLATEOBJ *ColorTranslation, - RECTL *DestRect, - POINTL *SourcePoint, - POINTL *MaskPoint, - BRUSHOBJ *Brush, - POINTL *BrushPoint, - ROP4 rop4) -{ - PBLTRECTFUNC BltRectFunc; - RECTL CombinedRect; - BOOL Ret = FALSE; - RECT_ENUM RectEnum; - BOOL EnumMore; - unsigned i; - POINTL Pt; - ULONG Direction; - - switch (rop4) - { - case ROP3_TO_ROP4(BLACKNESS): - case ROP3_TO_ROP4(PATCOPY): - case ROP3_TO_ROP4(WHITENESS): - case ROP3_TO_ROP4(PATINVERT): - case ROP3_TO_ROP4(DSTINVERT): - BltRectFunc = VGADDI_BltBrush; - break; - - case ROP3_TO_ROP4(SRCCOPY): - if (BMF_4BPP == Source->iBitmapFormat && BMF_4BPP == Dest->iBitmapFormat) - { - BltRectFunc = VGADDI_BltSrc; - } - else - { - return FALSE; - } - break; - - case R4_MASK: - BltRectFunc = VGADDI_BltMask; - break; - - default: return FALSE; } - switch(NULL == Clip ? DC_TRIVIAL : Clip->iDComplexity) - { - case DC_TRIVIAL: - Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, DestRect, - SourcePoint, MaskPoint, Brush, BrushPoint, - rop4); - break; - case DC_RECT: - // Clip the blt to the clip rectangle - VGADDI_IntersectRect(&CombinedRect, DestRect, &(Clip->rclBounds)); - Pt.x = SourcePoint->x + CombinedRect.left - DestRect->left; - Pt.y = SourcePoint->y + CombinedRect.top - DestRect->top; - Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, &CombinedRect, - &Pt, MaskPoint, Brush, BrushPoint, - rop4); - break; - case DC_COMPLEX: - Ret = TRUE; - if (Dest == Source) - { - if (DestRect->top <= SourcePoint->y) - { - Direction = DestRect->left < SourcePoint->x ? CD_RIGHTDOWN : CD_LEFTDOWN; - } - else - { - Direction = DestRect->left < SourcePoint->x ? CD_RIGHTUP : CD_LEFTUP; - } - } - else - { - Direction = CD_ANY; - } - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, Direction, 0); - do - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + /* Get the brush colour. */ + switch (GET_OPINDEX_FROM_ROP4(Rop4)) + { + case GET_OPINDEX_FROM_ROP3(PATCOPY): SolidColor = Brush->iSolidColor; break; + case GET_OPINDEX_FROM_ROP3(PATINVERT): SolidColor = Brush->iSolidColor; RasterOp = VGA_XOR; break; + case GET_OPINDEX_FROM_ROP3(WHITENESS): SolidColor = 0xF; break; + case GET_OPINDEX_FROM_ROP3(BLACKNESS): SolidColor = 0x0; break; + case GET_OPINDEX_FROM_ROP3(DSTINVERT): SolidColor = 0xF; RasterOp = VGA_XOR; break; + } - for (i = 0; i < RectEnum.c; i++) - { - VGADDI_IntersectRect(&CombinedRect, DestRect, RectEnum.arcl + i); - Pt.x = SourcePoint->x + CombinedRect.left - DestRect->left; - Pt.y = SourcePoint->y + CombinedRect.top - DestRect->top; - Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, &CombinedRect, - &Pt, MaskPoint, Brush, BrushPoint, rop4) && - Ret; - } - } - while (EnumMore); - break; - } + /* Select write mode 3. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x03); - return Ret; + /* Setup set/reset register. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x00); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, (UCHAR)SolidColor); + + /* Enable writes to all pixels. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); + + /* Set up data rotate. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, RasterOp); + + /* Fill any pixels on the left which don't fall into a full row of eight. */ + if ((DestRect->left % 8) != 0) + { + /* Disable writes to pixels outside of the destination rectangle. */ + Mask = (1 << (8 - (DestRect->left % 8))) - 1; + if ((DestRect->right - DestRect->left) < (8 - (DestRect->left % 8))) + Mask &= ~((1 << (8 - (DestRect->right % 8))) - 1); + + /* Write the same color to each pixel. */ + Video = (PUCHAR)vidmem + DestRect->top * 80 + (DestRect->left >> 3); + for (i = DestRect->top; i < DestRect->bottom; i++, Video += 80) + { + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, Mask); + } + + /* Have we finished. */ + if ((DestRect->right - DestRect->left) < (8 - (DestRect->left % 8))) + { + /* Restore write mode 2. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + + /* Set up data rotate. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + + return TRUE; + } + } + + /* Fill any whole rows of eight pixels. */ + Left = (DestRect->left + 7) & ~0x7; + Length = (DestRect->right >> 3) - (Left >> 3); + for (i = DestRect->top; i < DestRect->bottom; i++) + { + Video = (PUCHAR)vidmem + i * 80 + (Left >> 3); + for (j = 0; j < Length; j++, Video++) + { +#if 0 + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, 0xFF); +#else + char volatile Temp = *Video; + Temp |= 0; + *Video = 0xFF; +#endif + } + } + + /* Fill any pixels on the right which don't fall into a complete row. */ + if ((DestRect->right % 8) != 0) + { + /* Disable writes to pixels outside the destination rectangle. */ + Mask = ~((1 << (8 - (DestRect->right % 8))) - 1); + + Video = (PUCHAR)vidmem + DestRect->top * 80 + (DestRect->right >> 3); + for (i = DestRect->top; i < DestRect->bottom; i++, Video += 80) + { + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, Mask); + } + } + + /* Restore write mode 2. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + + /* Set up data rotate. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + + return TRUE; +} + +BOOL APIENTRY +VGADDI_BltSrc( + IN SURFOBJ* Dest, + IN SURFOBJ* Source, + IN SURFOBJ* Mask, + IN XLATEOBJ* ColorTranslation, + IN RECTL* DestRect, + IN POINTL* SourcePoint, + IN POINTL* MaskOrigin, + IN BRUSHOBJ* Brush, + IN POINTL* BrushOrigin, + IN ROP4 Rop4) +{ + PFN_VGABlt BltOperation; + ULONG SourceType; + + SourceType = Source->iType; + + if (SourceType == STYPE_BITMAP && Dest->iType == STYPE_DEVICE) + BltOperation = DIBtoVGA; + else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_BITMAP) + BltOperation = VGAtoDIB; + else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_DEVICE) + BltOperation = VGAtoVGA; + else if (SourceType == STYPE_DEVBITMAP && Dest->iType == STYPE_DEVICE) + BltOperation = DFBtoVGA; + else if (SourceType == STYPE_DEVICE && Dest->iType == STYPE_DEVBITMAP) + BltOperation = VGAtoDFB; + else + { + /* Punt blts not involving a device or a device-bitmap. */ + return FALSE; + } + + BltOperation(Dest, Source, ColorTranslation, DestRect, SourcePoint); + return TRUE; +} + +BOOL APIENTRY +VGADDI_BltMask( + IN SURFOBJ* Dest, + IN SURFOBJ* Source, + IN SURFOBJ* Mask, + IN XLATEOBJ* ColorTranslation, + IN RECTL* DestRect, + IN POINTL* SourcePoint, + IN POINTL* MaskPoint, + IN BRUSHOBJ* Brush, + IN POINTL* BrushPoint, + IN ROP4 Rop4) +{ + LONG i, j, dx, dy, c8; + BYTE *tMask, *lMask; + + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; + + if (ColorTranslation == NULL) + { + if (Mask != NULL) + { + tMask = Mask->pvScan0; + for (j = 0; j < dy; j++) + { + lMask = tMask; + c8 = 0; + for (i = 0; i < dx; i++) + { + if((*lMask & maskbit[c8]) != 0) + vgaPutPixel(DestRect->left + i, DestRect->top + j, Brush->iSolidColor); + c8++; + if(c8 == 8) + { + lMask++; + c8=0; + } + } + tMask += Mask->lDelta; + } + } + } + return TRUE; +} + +BOOL APIENTRY +DrvBitBlt( + IN SURFOBJ *Dest, + IN SURFOBJ *Source, + IN SURFOBJ *Mask, + IN CLIPOBJ *Clip, + IN XLATEOBJ *ColorTranslation, + IN RECTL *DestRect, + IN POINTL *SourcePoint, + IN POINTL *MaskPoint, + IN BRUSHOBJ *Brush, + IN POINTL *BrushPoint, + IN ROP4 rop4) +{ + PBLTRECTFUNC BltRectFunc; + RECTL CombinedRect; + BOOL Ret = FALSE; + RECT_ENUM RectEnum; + BOOL EnumMore; + UINT i; + POINTL Pt; + ULONG Direction; + + switch (rop4) + { + case ROP3_TO_ROP4(BLACKNESS): + case ROP3_TO_ROP4(PATCOPY): + case ROP3_TO_ROP4(WHITENESS): + case ROP3_TO_ROP4(PATINVERT): + case ROP3_TO_ROP4(DSTINVERT): + BltRectFunc = VGADDI_BltBrush; + break; + + case ROP3_TO_ROP4(SRCCOPY): + if (BMF_4BPP == Source->iBitmapFormat && BMF_4BPP == Dest->iBitmapFormat) + BltRectFunc = VGADDI_BltSrc; + else + return FALSE; + break; + + case R4_MASK: + BltRectFunc = VGADDI_BltMask; + break; + + default: + return FALSE; + } + + switch (NULL == Clip ? DC_TRIVIAL : Clip->iDComplexity) + { + case DC_TRIVIAL: + Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, DestRect, + SourcePoint, MaskPoint, Brush, BrushPoint, + rop4); + break; + case DC_RECT: + /* Clip the blt to the clip rectangle */ + VGADDI_IntersectRect(&CombinedRect, DestRect, &(Clip->rclBounds)); + Pt.x = SourcePoint->x + CombinedRect.left - DestRect->left; + Pt.y = SourcePoint->y + CombinedRect.top - DestRect->top; + Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, &CombinedRect, + &Pt, MaskPoint, Brush, BrushPoint, + rop4); + break; + case DC_COMPLEX: + Ret = TRUE; + if (Dest == Source) + { + if (DestRect->top <= SourcePoint->y) + Direction = DestRect->left < SourcePoint->x ? CD_RIGHTDOWN : CD_LEFTDOWN; + else + Direction = DestRect->left < SourcePoint->x ? CD_RIGHTUP : CD_LEFTUP; + } + else + { + Direction = CD_ANY; + } + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, Direction, 0); + do + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + + for (i = 0; i < RectEnum.c; i++) + { + VGADDI_IntersectRect(&CombinedRect, DestRect, RectEnum.arcl + i); + Pt.x = SourcePoint->x + CombinedRect.left - DestRect->left; + Pt.y = SourcePoint->y + CombinedRect.top - DestRect->top; + Ret = (*BltRectFunc)(Dest, Source, Mask, ColorTranslation, &CombinedRect, + &Pt, MaskPoint, Brush, BrushPoint, rop4) && + Ret; + } + } while (EnumMore); + break; + } + + return Ret; } diff --git a/reactos/drivers/video/displays/vga/objects/copybits.c b/reactos/drivers/video/displays/vga/objects/copybits.c index ccd74b8096e..41add923517 100644 --- a/reactos/drivers/video/displays/vga/objects/copybits.c +++ b/reactos/drivers/video/displays/vga/objects/copybits.c @@ -1,38 +1,47 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/copybits.c + * PURPOSE: + * PROGRAMMERS: + */ + #include "../vgaddi.h" #include "../vgavideo/vgavideo.h" #include BOOL APIENTRY -DrvCopyBits(OUT SURFOBJ* DestObj, - IN SURFOBJ* SourceObj, - IN CLIPOBJ* ClipObj, - IN XLATEOBJ* XLateObj, - IN RECTL* DestRectL, - IN POINTL* SrcPointL) +DrvCopyBits( + OUT SURFOBJ* DestObj, + IN SURFOBJ* SourceObj, + IN CLIPOBJ* ClipObj, + IN XLATEOBJ* XLateObj, + IN RECTL* DestRectL, + IN POINTL* SrcPointL) { - BOOL Done = FALSE; + BOOL Done = FALSE; - if (STYPE_BITMAP == DestObj->iType && BMF_4BPP == DestObj->iBitmapFormat && - STYPE_DEVICE == SourceObj->iType) + if (STYPE_BITMAP == DestObj->iType && BMF_4BPP == DestObj->iBitmapFormat && + STYPE_DEVICE == SourceObj->iType) { - /* Screen to 4 BPP DIB */ - DIB_BltFromVGA(SrcPointL->x, SrcPointL->y, - DestRectL->right - DestRectL->left, - DestRectL->bottom - DestRectL->top, - DestObj->pvScan0, DestObj->lDelta); - Done = TRUE; + /* Screen to 4 BPP DIB */ + DIB_BltFromVGA(SrcPointL->x, SrcPointL->y, + DestRectL->right - DestRectL->left, + DestRectL->bottom - DestRectL->top, + DestObj->pvScan0, DestObj->lDelta); + Done = TRUE; } - else if (STYPE_DEVICE == DestObj->iType && - STYPE_BITMAP == SourceObj->iType && BMF_4BPP == SourceObj->iBitmapFormat) + else if (STYPE_DEVICE == DestObj->iType && + STYPE_BITMAP == SourceObj->iType && BMF_4BPP == SourceObj->iBitmapFormat) { - /* 4 BPP DIB to Screen */ - DIB_BltToVGA(DestRectL->left, DestRectL->top, - DestRectL->right - DestRectL->left, - DestRectL->bottom - DestRectL->top, - SourceObj->pvScan0, SourceObj->lDelta, - 0); - Done = TRUE; + /* 4 BPP DIB to Screen */ + DIB_BltToVGA(DestRectL->left, DestRectL->top, + DestRectL->right - DestRectL->left, + DestRectL->bottom - DestRectL->top, + SourceObj->pvScan0, SourceObj->lDelta, + 0); + Done = TRUE; } - return Done; + return Done; } diff --git a/reactos/drivers/video/displays/vga/objects/lineto.c b/reactos/drivers/video/displays/vga/objects/lineto.c index fcc9c803673..5a3918f63de 100644 --- a/reactos/drivers/video/displays/vga/objects/lineto.c +++ b/reactos/drivers/video/displays/vga/objects/lineto.c @@ -1,21 +1,9 @@ /* - * ReactOS VGA driver - * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team - * - * 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., 675 Mass Ave, Cambridge, MA 02139, USA. - * + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/lineto.c + * PURPOSE: + * PROGRAMMERS: Copyright (C) 1998-2003 ReactOS Team */ #include "../vgaddi.h" @@ -25,263 +13,279 @@ * Draw a line from top-left to bottom-right */ static void FASTCALL -vgaNWtoSE(CLIPOBJ* Clip, BRUSHOBJ* Brush, LONG x, LONG y, LONG deltax, LONG deltay) +vgaNWtoSE( + IN CLIPOBJ* Clip, + IN BRUSHOBJ* Brush, + IN LONG x, + IN LONG y, + IN LONG deltax, + IN LONG deltay) { - int i; - int error; - BOOLEAN EnumMore; - PRECTL ClipRect; - RECT_ENUM RectEnum; - ULONG Pixel = Brush->iSolidColor; - LONG delta; + int i; + int error; + BOOLEAN EnumMore; + PRECTL ClipRect; + RECT_ENUM RectEnum; + ULONG Pixel = Brush->iSolidColor; + LONG delta; - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - delta = max(deltax, deltay); - i = 0; - error = delta/2; - while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + delta = max(deltax, deltay); + i = 0; + error = delta / 2; + while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) { - while ((ClipRect < RectEnum.arcl + RectEnum.c /* there's still a current clip rect */ - && (ClipRect->bottom <= y /* but it's above us */ - || (ClipRect->top <= y && ClipRect->right <= x))) /* or to the left of us */ - || EnumMore) /* no current clip rect, but rects left */ - { - /* Skip to the next clip rect */ - if (RectEnum.arcl + RectEnum.c <= ClipRect) - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - } - else - { - ClipRect++; - } - } - if ( ClipRect < RectEnum.arcl + RectEnum.c ) /* If there's no current clip rect we're done */ - { - if (ClipRect->left <= x && ClipRect->top <= y) - { - vgaPutPixel ( x, y, Pixel ); - } - if ( deltax < deltay ) - { - y++; - error += deltax; - if ( error >= deltay ) - { - x++; - error -= deltay; - } - } - else - { - x++; - error += deltay; - if ( error >= deltax ) - { - y++; - error -= deltax; - } - } - i++; - } + while ((ClipRect < RectEnum.arcl + RectEnum.c /* there's still a current clip rect */ + && (ClipRect->bottom <= y /* but it's above us */ + || (ClipRect->top <= y && ClipRect->right <= x))) /* or to the left of us */ + || EnumMore) /* no current clip rect, but rects left */ + { + /* Skip to the next clip rect */ + if (RectEnum.arcl + RectEnum.c <= ClipRect) + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + } + else + { + ClipRect++; + } + } + if ( ClipRect < RectEnum.arcl + RectEnum.c ) /* If there's no current clip rect we're done */ + { + if (ClipRect->left <= x && ClipRect->top <= y) + vgaPutPixel ( x, y, Pixel ); + if ( deltax < deltay ) + { + y++; + error += deltax; + if ( error >= deltay ) + { + x++; + error -= deltay; + } + } + else + { + x++; + error += deltay; + if ( error >= deltax ) + { + y++; + error -= deltax; + } + } + i++; + } } } static void FASTCALL -vgaSWtoNE(CLIPOBJ* Clip, BRUSHOBJ* Brush, LONG x, LONG y, LONG deltax, LONG deltay) +vgaSWtoNE( + IN CLIPOBJ* Clip, + IN BRUSHOBJ* Brush, + IN LONG x, + IN LONG y, + IN LONG deltax, + IN LONG deltay) { - int i; - int error; - BOOLEAN EnumMore; - PRECTL ClipRect; - RECT_ENUM RectEnum; - ULONG Pixel = Brush->iSolidColor; - LONG delta; + int i; + int error; + BOOLEAN EnumMore; + PRECTL ClipRect; + RECT_ENUM RectEnum; + ULONG Pixel = Brush->iSolidColor; + LONG delta; - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTUP, 0); - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - delta = max(deltax, deltay); - i = 0; - error = delta/2; - while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTUP, 0); + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + delta = max(deltax, deltay); + i = 0; + error = delta / 2; + while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) { - while ((ClipRect < RectEnum.arcl + RectEnum.c - && (y < ClipRect->top - || (y < ClipRect->bottom && ClipRect->right <= x))) - || EnumMore) - { - if (RectEnum.arcl + RectEnum.c <= ClipRect) - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - } - else - { - ClipRect++; - } - } - if (ClipRect < RectEnum.arcl + RectEnum.c) - { - if (ClipRect->left <= x && y < ClipRect->bottom) - { - vgaPutPixel(x, y, Pixel); - } - if (deltax < deltay) - { - y--; - error = error + deltax; - if (deltay <= error) - { - x++; - error = error - deltay; - } - } - else - { - x++; - error = error + deltay; - if (deltax <= error) - { - y--; - error = error - deltax; - } - } - i++; - } + while ((ClipRect < RectEnum.arcl + RectEnum.c + && (y < ClipRect->top + || (y < ClipRect->bottom && ClipRect->right <= x))) + || EnumMore) + { + if (RectEnum.arcl + RectEnum.c <= ClipRect) + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + } + else + { + ClipRect++; + } + } + if (ClipRect < RectEnum.arcl + RectEnum.c) + { + if (ClipRect->left <= x && y < ClipRect->bottom) + vgaPutPixel(x, y, Pixel); + if (deltax < deltay) + { + y--; + error = error + deltax; + if (deltay <= error) + { + x++; + error = error - deltay; + } + } + else + { + x++; + error = error + deltay; + if (deltax <= error) + { + y--; + error = error - deltax; + } + } + i++; + } } } static void FASTCALL -vgaNEtoSW(CLIPOBJ* Clip, BRUSHOBJ* Brush, LONG x, LONG y, LONG deltax, LONG deltay) +vgaNEtoSW( + IN CLIPOBJ* Clip, + IN BRUSHOBJ* Brush, + IN LONG x, + IN LONG y, + IN LONG deltax, + IN LONG deltay) { - int i; - int error; - BOOLEAN EnumMore; - PRECTL ClipRect; - RECT_ENUM RectEnum; - ULONG Pixel = Brush->iSolidColor; - LONG delta; + int i; + int error; + BOOLEAN EnumMore; + PRECTL ClipRect; + RECT_ENUM RectEnum; + ULONG Pixel = Brush->iSolidColor; + LONG delta; - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_LEFTDOWN, 0); - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - delta = max(deltax, deltay); - i = 0; - error = delta/2; - while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_LEFTDOWN, 0); + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + delta = max(deltax, deltay); + i = 0; + error = delta / 2; + while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) { - while ((ClipRect < RectEnum.arcl + RectEnum.c - && (ClipRect->bottom <= y - || (ClipRect->top <= y && x < ClipRect->left))) - || EnumMore) - { - if (RectEnum.arcl + RectEnum.c <= ClipRect) - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - } - else - { - ClipRect++; - } - } - if (ClipRect < RectEnum.arcl + RectEnum.c) - { - if (x < ClipRect->right && ClipRect->top <= y) - { - vgaPutPixel(x, y, Pixel); - } - if (deltax < deltay) - { - y++; - error = error + deltax; - if (deltay <= error) - { - x--; - error = error - deltay; - } - } - else - { - x--; - error = error + deltay; - if (deltax <= error) - { - y++; - error = error - deltax; - } - } - i++; - } + while ((ClipRect < RectEnum.arcl + RectEnum.c + && (ClipRect->bottom <= y + || (ClipRect->top <= y && x < ClipRect->left))) + || EnumMore) + { + if (RectEnum.arcl + RectEnum.c <= ClipRect) + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + } + else + { + ClipRect++; + } + } + if (ClipRect < RectEnum.arcl + RectEnum.c) + { + if (x < ClipRect->right && ClipRect->top <= y) + vgaPutPixel(x, y, Pixel); + if (deltax < deltay) + { + y++; + error = error + deltax; + if (deltay <= error) + { + x--; + error = error - deltay; + } + } + else + { + x--; + error = error + deltay; + if (deltax <= error) + { + y++; + error = error - deltax; + } + } + i++; + } } } static void FASTCALL -vgaSEtoNW(CLIPOBJ* Clip, BRUSHOBJ* Brush, LONG x, LONG y, LONG deltax, LONG deltay) +vgaSEtoNW( + IN CLIPOBJ* Clip, + IN BRUSHOBJ* Brush, + IN LONG x, + IN LONG y, + IN LONG deltax, + IN LONG deltay) { - int i; - int error; - BOOLEAN EnumMore; - PRECTL ClipRect; - RECT_ENUM RectEnum; - ULONG Pixel = Brush->iSolidColor; - LONG delta; + int i; + int error; + BOOLEAN EnumMore; + PRECTL ClipRect; + RECT_ENUM RectEnum; + ULONG Pixel = Brush->iSolidColor; + LONG delta; - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_LEFTUP, 0); - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - delta = max(deltax, deltay); - i = 0; - error = delta/2; - while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_LEFTUP, 0); + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + delta = max(deltax, deltay); + i = 0; + error = delta / 2; + while (i < delta && (ClipRect < RectEnum.arcl + RectEnum.c || EnumMore)) { - while ((ClipRect < RectEnum.arcl + RectEnum.c - && (y < ClipRect->top - || (y < ClipRect->bottom && x < ClipRect->left))) - || EnumMore) - { - if (RectEnum.arcl + RectEnum.c <= ClipRect) - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - ClipRect = RectEnum.arcl; - } - else - { - ClipRect++; - } - } - if (ClipRect < RectEnum.arcl + RectEnum.c) - { - if (x < ClipRect->right && y < ClipRect->bottom) - { - vgaPutPixel(x, y, Pixel); - } - if (deltax < deltay) - { - y--; - error = error + deltax; - if (deltay <= error) - { - x--; - error = error - deltay; - } - } - else - { - x--; - error = error + deltay; - if (deltax <= error) - { - y--; - error = error - deltax; - } - } - i++; - } + while ((ClipRect < RectEnum.arcl + RectEnum.c + && (y < ClipRect->top + || (y < ClipRect->bottom && x < ClipRect->left))) + || EnumMore) + { + if (RectEnum.arcl + RectEnum.c <= ClipRect) + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + ClipRect = RectEnum.arcl; + } + else + { + ClipRect++; + } + } + if (ClipRect < RectEnum.arcl + RectEnum.c) + { + if (x < ClipRect->right && y < ClipRect->bottom) + vgaPutPixel(x, y, Pixel); + if (deltax < deltay) + { + y--; + error = error + deltax; + if (deltay <= error) + { + x--; + error = error - deltay; + } + } + else + { + x--; + error = error + deltay; + if (deltax <= error) + { + y--; + error = error - deltax; + } + } + i++; + } } } @@ -290,124 +294,114 @@ vgaSEtoNW(CLIPOBJ* Clip, BRUSHOBJ* Brush, LONG x, LONG y, LONG deltax, LONG delt * FIXME: Non-solid Brush */ BOOL APIENTRY -DrvLineTo(SURFOBJ *DestObj, - CLIPOBJ *Clip, - BRUSHOBJ *Brush, - LONG x1, - LONG y1, - LONG x2, - LONG y2, - RECTL *RectBounds, - MIX mix) +DrvLineTo( + IN SURFOBJ *DestObj, + IN CLIPOBJ *Clip, + IN BRUSHOBJ *Brush, + IN LONG x1, + IN LONG y1, + IN LONG x2, + IN LONG y2, + IN RECTL *RectBounds, + IN MIX mix) { - LONG x, y, deltax, deltay, xchange, ychange, hx, vy; - ULONG i; - ULONG Pixel = Brush->iSolidColor; - RECT_ENUM RectEnum; - BOOL EnumMore; + LONG x, y, deltax, deltay, xchange, ychange, hx, vy; + ULONG i; + ULONG Pixel = Brush->iSolidColor; + RECT_ENUM RectEnum; + BOOL EnumMore; - x = x1; - y = y1; - deltax = x2 - x1; - deltay = y2 - y1; + x = x1; + y = y1; + deltax = x2 - x1; + deltay = y2 - y1; - if (deltax < 0) + if (deltax < 0) { - xchange = -1; - deltax = - deltax; - hx = x2+1; - //x--; + xchange = -1; + deltax = - deltax; + hx = x2+1; + //x--; } - else + else { - xchange = 1; - hx = x1; + xchange = 1; + hx = x1; } - if (deltay < 0) + if (deltay < 0) { - ychange = -1; - deltay = - deltay; - vy = y2+1; - //y--; + ychange = -1; + deltay = - deltay; + vy = y2+1; + //y--; } - else + else { - ychange = 1; - vy = y1; + ychange = 1; + vy = y1; } - if (y1 == y2) + if (y1 == y2) { - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); - do - { - EnumMore = CLIPOBJ_bEnum(Clip, sizeof(RectEnum), (PVOID) &RectEnum); - for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= y1; i++) - { - if (y1 < RectEnum.arcl[i].bottom && - RectEnum.arcl[i].left <= hx + deltax && - hx < RectEnum.arcl[i].right) - { - - vgaHLine(max(hx, RectEnum.arcl[i].left), y1, - min(hx + deltax, RectEnum.arcl[i].right) - -max(hx, RectEnum.arcl[i].left), Pixel); - } - } - } - while (EnumMore); + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); + do + { + EnumMore = CLIPOBJ_bEnum(Clip, sizeof(RectEnum), (PVOID) &RectEnum); + for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= y1; i++) + { + if (y1 < RectEnum.arcl[i].bottom && + RectEnum.arcl[i].left <= hx + deltax && + hx < RectEnum.arcl[i].right) + { + vgaHLine(max(hx, RectEnum.arcl[i].left), y1, + min(hx + deltax, RectEnum.arcl[i].right) + -max(hx, RectEnum.arcl[i].left), Pixel); + } + } + } while (EnumMore); } - else if (x1 == x2) + else if (x1 == x2) { - CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); - do - { - EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); - for (i = 0; i < RectEnum.c; i++) - { - if (RectEnum.arcl[i].left <= x1 && - x1 < RectEnum.arcl[i].right && - RectEnum.arcl[i].top <= vy + deltay && - vy < RectEnum.arcl[i].bottom) - { - vgaVLine(x1, - max(vy, RectEnum.arcl[i].top), - min(vy + deltay, RectEnum.arcl[i].bottom) - - max(vy, RectEnum.arcl[i].top), - Pixel); - } - } - } - while (EnumMore); + CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); + do + { + EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + for (i = 0; i < RectEnum.c; i++) + { + if (RectEnum.arcl[i].left <= x1 && + x1 < RectEnum.arcl[i].right && + RectEnum.arcl[i].top <= vy + deltay && + vy < RectEnum.arcl[i].bottom) + { + vgaVLine(x1, + max(vy, RectEnum.arcl[i].top), + min(vy + deltay, RectEnum.arcl[i].bottom) + - max(vy, RectEnum.arcl[i].top), + Pixel); + } + } + } while (EnumMore); } - else + else { - if (0 < xchange) - { - if (0 < ychange) - { - vgaNWtoSE(Clip, Brush, x, y, deltax, deltay); - } - else - { - vgaSWtoNE(Clip, Brush, x, y, deltax, deltay); - } - } - else - { - if (0 < ychange) - { - vgaNEtoSW(Clip, Brush, x, y, deltax, deltay); - } - else - { - vgaSEtoNW(Clip, Brush, x, y, deltax, deltay); - } - } + if (0 < xchange) + { + if (0 < ychange) + vgaNWtoSE(Clip, Brush, x, y, deltax, deltay); + else + vgaSWtoNE(Clip, Brush, x, y, deltax, deltay); + } + else + { + if (0 < ychange) + vgaNEtoSW(Clip, Brush, x, y, deltax, deltay); + else + vgaSEtoNW(Clip, Brush, x, y, deltax, deltay); + } } - return TRUE; + return TRUE; } /* EOF */ diff --git a/reactos/drivers/video/displays/vga/objects/offscreen.c b/reactos/drivers/video/displays/vga/objects/offscreen.c index 4075c39fb79..571fcffdf3c 100644 --- a/reactos/drivers/video/displays/vga/objects/offscreen.c +++ b/reactos/drivers/video/displays/vga/objects/offscreen.c @@ -1,25 +1,9 @@ /* - * ReactOS kernel - * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team - * - * 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., 675 Mass Ave, Cambridge, MA 02139, USA. - */ -/* - * PROJECT: ReactOS VGA16 display driver - * FILE: drivers/dd/vga/display/objects/offscreen.c - * PURPOSE: Manages off-screen video memory. + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/offscreen.c + * PURPOSE: Manages off-screen video memory + * PROGRAMMERS: Copyright (C) 1998-2001 ReactOS Team */ /* INCLUDES ******************************************************************/ @@ -35,158 +19,161 @@ static LIST_ENTRY SavedBitsList; /* FUNCTIONS *****************************************************************/ VOID -VGADDI_BltFromSavedScreenBits(ULONG DestX, - ULONG DestY, - PSAVED_SCREEN_BITS Src, - ULONG SizeX, - ULONG SizeY) +VGADDI_BltFromSavedScreenBits( + IN ULONG DestX, + IN ULONG DestY, + IN PSAVED_SCREEN_BITS Src, + IN ULONG SizeX, + IN ULONG SizeY) { - PUCHAR DestOffset; - PUCHAR SrcOffset; - ULONG i, j; + PUCHAR DestOffset; + PUCHAR SrcOffset; + ULONG i, j; - /* Select write mode 1. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 1); + /* Select write mode 1. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 1); - SrcOffset = (PUCHAR)vidmem + Src->Offset; - for (i = 0; i < SizeY; i++) + SrcOffset = (PUCHAR)vidmem + Src->Offset; + for (i = 0; i < SizeY; i++) { - DestOffset = (PUCHAR)vidmem + (i + DestY) * 80 + (DestX >> 3); - //FIXME: in the loop below we should treat the case when SizeX is not divisible by 8, i.e. partial bytes - for (j = 0; j < SizeX>>3; j++, SrcOffset++, DestOffset++) - { - (VOID)READ_REGISTER_UCHAR(SrcOffset); - WRITE_REGISTER_UCHAR(DestOffset, 0); - } + DestOffset = (PUCHAR)vidmem + (i + DestY) * 80 + (DestX >> 3); + //FIXME: in the loop below we should treat the case when SizeX is not divisible by 8, i.e. partial bytes + for (j = 0; j < SizeX>>3; j++, SrcOffset++, DestOffset++) + { + (VOID)READ_REGISTER_UCHAR(SrcOffset); + WRITE_REGISTER_UCHAR(DestOffset, 0); + } } - /* Select write mode 2. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); + /* Select write mode 2. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); } VOID -VGADDI_BltToSavedScreenBits(PSAVED_SCREEN_BITS Dest, - ULONG SourceX, - ULONG SourceY, - ULONG SizeX, - ULONG SizeY) +VGADDI_BltToSavedScreenBits( + IN PSAVED_SCREEN_BITS Dest, + IN ULONG SourceX, + IN ULONG SourceY, + IN ULONG SizeX, + IN ULONG SizeY) { - PUCHAR DestOffset; - PUCHAR SrcOffset; - ULONG i, j; + PUCHAR DestOffset; + PUCHAR SrcOffset; + ULONG i, j; - /* Select write mode 1. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 1); + /* Select write mode 1. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 1); - DestOffset = (PUCHAR)vidmem + Dest->Offset; + DestOffset = (PUCHAR)vidmem + Dest->Offset; - for (i = 0; i < SizeY; i++) + for (i = 0; i < SizeY; i++) { - SrcOffset = (PUCHAR)vidmem + (SourceY + i) * 80 + (SourceX >> 3); - //FIXME: in the loop below we should treat the case when SizeX is not divisible by 8, i.e. partial bytes - for (j = 0; j < SizeX>>3; j++, SrcOffset++, DestOffset++) - { - (VOID)READ_REGISTER_UCHAR(SrcOffset); - WRITE_REGISTER_UCHAR(DestOffset, 0); - } + SrcOffset = (PUCHAR)vidmem + (SourceY + i) * 80 + (SourceX >> 3); + //FIXME: in the loop below we should treat the case when SizeX is not divisible by 8, i.e. partial bytes + for (j = 0; j < SizeX>>3; j++, SrcOffset++, DestOffset++) + { + (VOID)READ_REGISTER_UCHAR(SrcOffset); + WRITE_REGISTER_UCHAR(DestOffset, 0); + } } - /* Select write mode 2. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); + /* Select write mode 2. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); } VOID VGADDI_FreeSavedScreenBits(PSAVED_SCREEN_BITS SavedBits) { - SavedBits->Free = TRUE; + SavedBits->Free = TRUE; - if (SavedBits->ListEntry.Blink != &SavedBitsList) + if (SavedBits->ListEntry.Blink != &SavedBitsList) { - PSAVED_SCREEN_BITS Previous; + PSAVED_SCREEN_BITS Previous; - Previous = CONTAINING_RECORD(SavedBits->ListEntry.Blink, - SAVED_SCREEN_BITS, ListEntry); - if (Previous->Free) - { - Previous->Size += SavedBits->Size; - RemoveEntryList(&SavedBits->ListEntry); - EngFreeMem(SavedBits); - SavedBits = Previous; - } + Previous = CONTAINING_RECORD(SavedBits->ListEntry.Blink, + SAVED_SCREEN_BITS, ListEntry); + if (Previous->Free) + { + Previous->Size += SavedBits->Size; + RemoveEntryList(&SavedBits->ListEntry); + EngFreeMem(SavedBits); + SavedBits = Previous; + } } - if (SavedBits->ListEntry.Flink != &SavedBitsList) + if (SavedBits->ListEntry.Flink != &SavedBitsList) { - PSAVED_SCREEN_BITS Next; + PSAVED_SCREEN_BITS Next; - Next = CONTAINING_RECORD(SavedBits->ListEntry.Flink, SAVED_SCREEN_BITS, - ListEntry); - if (Next->Free) - { - SavedBits->Size += Next->Size; - RemoveEntryList(&SavedBits->ListEntry); - EngFreeMem(SavedBits); - } + Next = CONTAINING_RECORD(SavedBits->ListEntry.Flink, SAVED_SCREEN_BITS, + ListEntry); + if (Next->Free) + { + SavedBits->Size += Next->Size; + RemoveEntryList(&SavedBits->ListEntry); + EngFreeMem(SavedBits); + } } } PSAVED_SCREEN_BITS VGADDI_AllocSavedScreenBits(ULONG Size) { - PSAVED_SCREEN_BITS Current; - PLIST_ENTRY CurrentEntry; - PSAVED_SCREEN_BITS Best; - PSAVED_SCREEN_BITS New; + PSAVED_SCREEN_BITS Current; + PLIST_ENTRY CurrentEntry; + PSAVED_SCREEN_BITS Best; + PSAVED_SCREEN_BITS New; - Best = NULL; - CurrentEntry = SavedBitsList.Flink; - while (CurrentEntry != &SavedBitsList) + Best = NULL; + CurrentEntry = SavedBitsList.Flink; + while (CurrentEntry != &SavedBitsList) { - Current = CONTAINING_RECORD(CurrentEntry, SAVED_SCREEN_BITS, ListEntry); + Current = CONTAINING_RECORD(CurrentEntry, SAVED_SCREEN_BITS, ListEntry); - if (Current->Free && Current->Size >= Size && - (Best == NULL || (Current->Size - Size) < (Best->Size - Size))) - { - Best = Current; - } + if (Current->Free && Current->Size >= Size && + (Best == NULL || (Current->Size - Size) < (Best->Size - Size))) + { + Best = Current; + } - CurrentEntry = CurrentEntry->Flink; + CurrentEntry = CurrentEntry->Flink; } - if (Best == NULL) + if (!Best) + return NULL; + + if (Best->Size == Size) { - return(NULL); + Best->Free = FALSE; + return Best; } - if (Best->Size == Size) + else { - Best->Free = FALSE; - return(Best); - } - else - { - New = EngAllocMem(0, sizeof(SAVED_SCREEN_BITS), ALLOC_TAG); - New->Free = FALSE; - New->Offset = Best->Offset + Size; - New->Size = Size; - Best->Size -= Size; - InsertHeadList(&Best->ListEntry, &New->ListEntry); - return(New); + New = EngAllocMem(0, sizeof(SAVED_SCREEN_BITS), ALLOC_TAG); + New->Free = FALSE; + New->Offset = Best->Offset + Size; + New->Size = Size; + Best->Size -= Size; + InsertHeadList(&Best->ListEntry, &New->ListEntry); + return New; } } VOID -VGADDI_InitializeOffScreenMem(ULONG Start, ULONG Length) +VGADDI_InitializeOffScreenMem( + IN ULONG Start, + IN ULONG Length) { - PSAVED_SCREEN_BITS FreeBits; + PSAVED_SCREEN_BITS FreeBits; - InitializeListHead(&SavedBitsList); + InitializeListHead(&SavedBitsList); - FreeBits = EngAllocMem(0, sizeof(SAVED_SCREEN_BITS), ALLOC_TAG); - FreeBits->Free = TRUE; - FreeBits->Offset = Start; - FreeBits->Size = Length; - InsertHeadList(&SavedBitsList, &FreeBits->ListEntry); + FreeBits = EngAllocMem(0, sizeof(SAVED_SCREEN_BITS), ALLOC_TAG); + FreeBits->Free = TRUE; + FreeBits->Offset = Start; + FreeBits->Size = Length; + InsertHeadList(&SavedBitsList, &FreeBits->ListEntry); } diff --git a/reactos/drivers/video/displays/vga/objects/paint.c b/reactos/drivers/video/displays/vga/objects/paint.c index c343ccc8b62..2549ed449b1 100644 --- a/reactos/drivers/video/displays/vga/objects/paint.c +++ b/reactos/drivers/video/displays/vga/objects/paint.c @@ -1,3 +1,10 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/paint.c + * PURPOSE: + * PROGRAMMERS: + */ #include "../vgaddi.h" #include "../vgavideo/vgavideo.h" @@ -7,235 +14,242 @@ BOOL VGADDIFillSolid(SURFOBJ *Surface, RECTL Dimensions, ULONG iColor) { - int x, y, x2, y2, w, h, j; - ULONG offset, pre1; - ULONG orgpre1, orgx, midpre1, tmppre1; - int ileftpix, imidpix, irightpix; -/* double leftpix, midpix, rightpix;*/ - UCHAR a; + int x, y, x2, y2, w, h, j; + ULONG offset, pre1; + ULONG orgpre1, orgx, midpre1, tmppre1; + int ileftpix, imidpix, irightpix; +/* double leftpix, midpix, rightpix;*/ + UCHAR a; - // Swap dimensions so that x, y are at topmost left - if ( Dimensions.right < Dimensions.left ) - { - x = Dimensions.right; - x2 = Dimensions.left; - } - else - { - x2 = Dimensions.right; - x = Dimensions.left; - } - if ( Dimensions.bottom < Dimensions.top ) - { - y = Dimensions.bottom; - y2 = Dimensions.top; - } - else - { - y2 = Dimensions.bottom; - y = Dimensions.top; - } + /* Swap dimensions so that x, y are at topmost left */ + if ( Dimensions.right < Dimensions.left ) + { + x = Dimensions.right; + x2 = Dimensions.left; + } + else + { + x2 = Dimensions.right; + x = Dimensions.left; + } + if ( Dimensions.bottom < Dimensions.top ) + { + y = Dimensions.bottom; + y2 = Dimensions.top; + } + else + { + y2 = Dimensions.bottom; + y = Dimensions.top; + } - // Calculate the width and height - w = x2 - x; - h = y2 - y; + /* Calculate the width and height */ + w = x2 - x; + h = y2 - y; - DPRINT("VGADDIFillSolid: x:%d, y:%d, w:%d, h:%d\n", x, y, w, h); + DPRINT("VGADDIFillSolid: x:%d, y:%d, w:%d, h:%d\n", x, y, w, h); - // Calculate the starting offset - offset = xconv[x]+y80[y]; + /* Calculate the starting offset */ + offset = xconv[x]+y80[y]; - // Make a note of original x - orgx = x; + /* Make a note of original x */ + orgx = x; - // Calculate the left mask pixels, middle bytes and right mask pixel - ileftpix = 7 - mod8(x-1); - irightpix = mod8(x+w); - imidpix = (w-ileftpix-irightpix) / 8; + /* Calculate the left mask pixels, middle bytes and right mask pixel */ + ileftpix = 7 - mod8(x-1); + irightpix = mod8(x+w); + imidpix = (w-ileftpix-irightpix) / 8; - pre1 = xconv[(x-1)&~7] + y80[y]; - orgpre1=pre1; + pre1 = xconv[(x-1)&~7] + y80[y]; + orgpre1=pre1; - // check for overlap ( very horizontally skinny rect ) - if ( (ileftpix+irightpix) > w ) - { - int mask = startmasks[ileftpix] & endmasks[irightpix]; + /* check for overlap ( very horizontally skinny rect ) */ + if ( (ileftpix+irightpix) > w ) + { + int mask = startmasks[ileftpix] & endmasks[irightpix]; - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D,mask); + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D,mask); + + tmppre1 = pre1; + for ( j = y; j < y+h; j++ ) + { + a = READ_REGISTER_UCHAR ( vidmem+tmppre1 ); + WRITE_REGISTER_UCHAR ( vidmem+tmppre1, iColor ); + tmppre1 += 80; + } + return TRUE; + } + + if ( ileftpix > 0 ) + { + /* Write left pixels */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D,startmasks[ileftpix]); + + tmppre1 = pre1; + for ( j = y; j < y+h; j++ ) + { + a = READ_REGISTER_UCHAR(vidmem + tmppre1); + WRITE_REGISTER_UCHAR(vidmem + tmppre1, iColor); + tmppre1 += 80; + } + + /* Prepare new x for the middle */ + x = orgx + 8; + } + + if ( imidpix > 0 ) + { + midpre1=xconv[x] + y80[y]; + + /* Set mask to all pixels in byte */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); + + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xff); + + for ( j = y; j < y+h; j++ ) + { + memset(vidmem+midpre1, iColor, imidpix); // write middle pixels, no need to read in latch because of the width + midpre1 += 80; + } + } + + x = orgx + w - irightpix; + pre1 = xconv[x] + y80[y]; + + /* Write right pixels */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask bits + WRITE_PORT_UCHAR((PUCHAR)GRA_D,endmasks[irightpix]); - tmppre1 = pre1; for ( j = y; j < y+h; j++ ) { - a = READ_REGISTER_UCHAR ( vidmem+tmppre1 ); - WRITE_REGISTER_UCHAR ( vidmem+tmppre1, iColor ); - tmppre1 += 80; + a = READ_REGISTER_UCHAR(vidmem + pre1); + WRITE_REGISTER_UCHAR(vidmem + pre1, iColor); + pre1 += 80; } + return TRUE; - } - - if ( ileftpix > 0 ) - { - // Write left pixels - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D,startmasks[ileftpix]); - - tmppre1 = pre1; - for ( j = y; j < y+h; j++ ) - { - a = READ_REGISTER_UCHAR(vidmem + tmppre1); - WRITE_REGISTER_UCHAR(vidmem + tmppre1, iColor); - tmppre1 += 80; - } - - // Prepare new x for the middle - x = orgx + 8; - } - - if ( imidpix > 0 ) - { - midpre1=xconv[x] + y80[y]; - - // Set mask to all pixels in byte - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); - - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xff); - - for ( j = y; j < y+h; j++ ) - { - memset(vidmem+midpre1, iColor, imidpix); // write middle pixels, no need to read in latch because of the width - midpre1 += 80; - } - } - - x = orgx + w - irightpix; - pre1 = xconv[x] + y80[y]; - - // Write right pixels - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask bits - WRITE_PORT_UCHAR((PUCHAR)GRA_D,endmasks[irightpix]); - - for ( j = y; j < y+h; j++ ) - { - a = READ_REGISTER_UCHAR(vidmem + pre1); - WRITE_REGISTER_UCHAR(vidmem + pre1, iColor); - pre1 += 80; - } - - return TRUE; } -BOOL VGADDIPaintRgn(SURFOBJ *Surface, CLIPOBJ *ClipRegion, ULONG iColor, MIX Mix, - BRUSHINST *BrushInst, POINTL *BrushPoint) +BOOL VGADDIPaintRgn( + IN SURFOBJ *Surface, + IN CLIPOBJ *ClipRegion, + IN ULONG iColor, + IN MIX Mix, + IN BRUSHINST *BrushInst, + IN POINTL *BrushPoint) { - RECT_ENUM RectEnum; - BOOL EnumMore; + RECT_ENUM RectEnum; + BOOL EnumMore; - DPRINT("VGADDIPaintRgn: iMode: %d, iDComplexity: %d\n Color:%d\n", ClipRegion->iMode, ClipRegion->iDComplexity, iColor); - switch(ClipRegion->iMode) { + DPRINT("VGADDIPaintRgn: iMode: %d, iDComplexity: %d\n Color:%d\n", ClipRegion->iMode, ClipRegion->iDComplexity, iColor); + switch(ClipRegion->iMode) + { + case TC_RECTANGLES: - case TC_RECTANGLES: + /* Rectangular clipping can be handled without enumeration. + Note that trivial clipping is not possible, since the clipping + region defines the area to fill */ - /* Rectangular clipping can be handled without enumeration. - Note that trivial clipping is not possible, since the clipping - region defines the area to fill */ + if (ClipRegion->iDComplexity == DC_RECT) + { + DPRINT("VGADDIPaintRgn Rect:%d %d %d %d\n", ClipRegion->rclBounds.left, ClipRegion->rclBounds.top, ClipRegion->rclBounds.right, ClipRegion->rclBounds.bottom); + VGADDIFillSolid(Surface, ClipRegion->rclBounds, iColor); + } + else + { + /* Enumerate all the rectangles and draw them */ - if (ClipRegion->iDComplexity == DC_RECT) - { - DPRINT("VGADDIPaintRgn Rect:%d %d %d %d\n", ClipRegion->rclBounds.left, ClipRegion->rclBounds.top, ClipRegion->rclBounds.right, ClipRegion->rclBounds.bottom); - VGADDIFillSolid(Surface, ClipRegion->rclBounds, iColor); - } else { - /* Enumerate all the rectangles and draw them */ + CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); - CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); + do + { + UINT i; + EnumMore = CLIPOBJ_bEnum(ClipRegion, sizeof(RectEnum), (PVOID) &RectEnum); + DPRINT("EnumMore: %d, count: %d\n", EnumMore, RectEnum.c); + for( i=0; iiSolidColor; // FIXME: Realizations and the like + iSolidColor = Brush->iSolidColor; // FIXME: Realizations and the like - // If the foreground and background Mixes are the same, - // (LATER or if there's no brush mask) - // then see if we can use the solid brush accelerators + // If the foreground and background Mixes are the same, + // (LATER or if there's no brush mask) + // then see if we can use the solid brush accelerators - // FIXME: Put in the mix switch below - // Brush color parameter doesn't matter for these rops - return(VGADDIPaintRgn(Surface, ClipRegion, iSolidColor, Mix, NULL, BrushOrigin)); + // FIXME: Put in the mix switch below + // Brush color parameter doesn't matter for these rops + return(VGADDIPaintRgn(Surface, ClipRegion, iSolidColor, Mix, NULL, BrushOrigin)); - if ((Mix & 0xFF) == ((Mix >> 8) & 0xFF)) - { - switch (Mix & 0xFF) - { - case 0: - break; + if ((Mix & 0xFF) == ((Mix >> 8) & 0xFF)) + { + switch (Mix & 0xFF) + { + case 0: + break; - // FIXME: Implement all these millions of ROPs - // For now we don't support brushes -- everything is solid + // FIXME: Implement all these millions of ROPs + // For now we don't support brushes -- everything is solid - case R2_MASKNOTPEN: - case R2_NOTCOPYPEN: - case R2_XORPEN: - case R2_MASKPEN: - case R2_NOTXORPEN: - case R2_MERGENOTPEN: - case R2_COPYPEN: - case R2_MERGEPEN: - case R2_NOTMERGEPEN: - case R2_MASKPENNOT: - case R2_NOTMASKPEN: - case R2_MERGEPENNOT: + case R2_MASKNOTPEN: + case R2_NOTCOPYPEN: + case R2_XORPEN: + case R2_MASKPEN: + case R2_NOTXORPEN: + case R2_MERGENOTPEN: + case R2_COPYPEN: + case R2_MERGEPEN: + case R2_NOTMERGEPEN: + case R2_MASKPENNOT: + case R2_NOTMASKPEN: + case R2_MERGEPENNOT: - // Rops that are implicit solid colors - case R2_NOT: - case R2_WHITE: - case R2_BLACK: + // Rops that are implicit solid colors + case R2_NOT: + case R2_WHITE: + case R2_BLACK: - // FIXME: The Paint region belongs HERE + // FIXME: The Paint region belongs HERE - case R2_NOP: - return(TRUE); + case R2_NOP: + return TRUE; - default: - break; - } - } + default: + break; + } + } /* doBitBlt: - // If VGADDIPaint can't do it, VGADDIBitBlt can.. or it might just loop back - // here and we have a nice infinite loop + // If VGADDIPaint can't do it, VGADDIBitBlt can.. or it might just loop back + // here and we have a nice infinite loop - return( VGADDIBitBlt(Surface, (SURFOBJ *)NULL, (SURFOBJ *)NULL, ClipRegion, - (XLATEOBJ *)NULL, &ClipRegion->rclBounds, - NULL, (POINTL *)NULL, Brush, BrushOrigin, - NULL) ); UNIMPLEMENTED */ + return( VGADDIBitBlt(Surface, (SURFOBJ *)NULL, (SURFOBJ *)NULL, ClipRegion, + (XLATEOBJ *)NULL, &ClipRegion->rclBounds, + NULL, (POINTL *)NULL, Brush, BrushOrigin, + NULL) ); UNIMPLEMENTED */ } diff --git a/reactos/drivers/video/displays/vga/objects/pointer.c b/reactos/drivers/video/displays/vga/objects/pointer.c index b7c9875951e..bbe112b1626 100644 --- a/reactos/drivers/video/displays/vga/objects/pointer.c +++ b/reactos/drivers/video/displays/vga/objects/pointer.c @@ -1,25 +1,9 @@ /* - * ReactOS kernel - * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team - * - * 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., 675 Mass Ave, Cambridge, MA 02139, USA. - */ -/* - * PROJECT: ReactOS VGA16 display driver - * FILE: drivers/dd/vga/display/objects/pointer.c - * PURPOSE: Draws the mouse pointer. + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/pointer.c + * PURPOSE: Draws the mouse pointer + * PROGRAMMERS: Copyright (C) 1998-2001 ReactOS Team */ /* INCLUDES ******************************************************************/ @@ -38,356 +22,355 @@ static VOID VGADDI_ShowCursor(PPDEV ppdev, PRECTL prcl); /* FUNCTIONS *****************************************************************/ VOID -VGADDI_BltPointerToVGA(LONG StartX, LONG StartY, ULONG SizeX, - ULONG SizeY, PUCHAR MaskBits, ULONG MaskPitch, ULONG MaskOp) +VGADDI_BltPointerToVGA( + IN LONG StartX, + IN LONG StartY, + IN ULONG SizeX, + IN ULONG SizeY, + IN PUCHAR MaskBits, + IN ULONG MaskPitch, + IN ULONG MaskOp) { - ULONG DestX, EndX, DestY, EndY; - UCHAR Mask; - PUCHAR Video; - PUCHAR Src; - UCHAR SrcValue; - ULONG i, j; - ULONG Left; - ULONG Length; - LONG Bits; + ULONG DestX, EndX, DestY, EndY; + UCHAR Mask; + PUCHAR Video; + PUCHAR Src; + UCHAR SrcValue; + ULONG i, j; + ULONG Left; + ULONG Length; + LONG Bits; - DestX = StartX < 0 ? 0 : StartX; - DestY = StartY < 0 ? 0 : StartY; - EndX = StartX + SizeX; - EndY = StartY + SizeY; + DestX = StartX < 0 ? 0 : StartX; + DestY = StartY < 0 ? 0 : StartY; + EndX = StartX + SizeX; + EndY = StartY + SizeY; - /* Set write mode zero. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0); + /* Set write mode zero. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0); - /* Select raster op. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 3); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, MaskOp); + /* Select raster op. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 3); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, MaskOp); - if ((DestX % 8) != 0) + if ((DestX % 8) != 0) { - /* Disable writes to pixels outside of the destination rectangle. */ - Mask = (1 << (8 - (DestX % 8))) - 1; - if ((EndX - DestX) < (8 - (DestX % 8))) - { - Mask &= ~((1 << (8 - (EndX % 8))) - 1); - } - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, Mask); + /* Disable writes to pixels outside of the destination rectangle. */ + Mask = (1 << (8 - (DestX % 8))) - 1; + if ((EndX - DestX) < (8 - (DestX % 8))) + { + Mask &= ~((1 << (8 - (EndX % 8))) - 1); + } + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, Mask); - /* Write the mask. */ - Video = (PUCHAR)vidmem + DestY * 80 + (DestX >> 3); - Src = MaskBits + (SizeY - (DestY - StartY)) * MaskPitch; - for (i = DestY; i < EndY; i++, Video += 80) - { - Src -= MaskPitch; - SrcValue = (*Src) >> (DestX % 8); - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, SrcValue); - } + /* Write the mask. */ + Video = (PUCHAR)vidmem + DestY * 80 + (DestX >> 3); + Src = MaskBits + (SizeY - (DestY - StartY)) * MaskPitch; + for (i = DestY; i < EndY; i++, Video += 80) + { + Src -= MaskPitch; + SrcValue = (*Src) >> (DestX % 8); + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, SrcValue); + } } - /* Enable writes to all pixels. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); + /* Enable writes to all pixels. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); - /* Have we finished. */ - if ((EndX - DestX) < (8 - (DestX % 8))) + /* Have we finished. */ + if ((EndX - DestX) < (8 - (DestX % 8))) + return; + + /* Fill any whole rows of eight pixels. */ + Left = (DestX + 7) & ~0x7; + Length = (EndX >> 3) - (Left >> 3); + Bits = StartX; + while (Bits < 0) + Bits += 8; + Bits = Bits % 8; + for (i = DestY; i < EndY; i++) { - return; + Video = (PUCHAR)vidmem + i * 80 + (Left >> 3); + Src = MaskBits + (EndY - i - 1) * MaskPitch + ((DestX - StartX) >> 3); + for (j = 0; j < Length; j++, Video++, Src++) + { + if (Bits != 0) + { + SrcValue = (Src[0] << (8 - Bits)); + SrcValue |= (Src[1] >> Bits); + } + else + { + SrcValue = Src[0]; + } + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, SrcValue); + } } - /* Fill any whole rows of eight pixels. */ - Left = (DestX + 7) & ~0x7; - Length = (EndX >> 3) - (Left >> 3); - Bits = StartX; - while (Bits < 0) + /* Fill any pixels on the right which don't fall into a complete row. */ + if ((EndX % 8) != 0) { - Bits += 8; - } - Bits = Bits % 8; - for (i = DestY; i < EndY; i++) - { - Video = (PUCHAR)vidmem + i * 80 + (Left >> 3); - Src = MaskBits + (EndY - i - 1) * MaskPitch + ((DestX - StartX) >> 3); - for (j = 0; j < Length; j++, Video++, Src++) - { - if (Bits != 0) - { - SrcValue = (Src[0] << (8 - Bits)); - SrcValue |= (Src[1] >> Bits); - } - else - { - SrcValue = Src[0]; - } - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, SrcValue); - } + /* Disable writes to pixels outside the destination rectangle. */ + Mask = ~((1 << (8 - (EndX % 8))) - 1); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, Mask); + + Video = (PUCHAR)vidmem + DestY * 80 + (EndX >> 3); + Src = MaskBits + (SizeY - (DestY - StartY)) * MaskPitch + (SizeX >> 3) - 1; + for (i = DestY; i < EndY; i++, Video += 80) + { + Src -= MaskPitch; + SrcValue = (Src[0] << (8 - Bits)); + (VOID)READ_REGISTER_UCHAR(Video); + WRITE_REGISTER_UCHAR(Video, SrcValue); + } + + /* Restore the default write masks. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); } - /* Fill any pixels on the right which don't fall into a complete row. */ - if ((EndX % 8) != 0) - { - /* Disable writes to pixels outside the destination rectangle. */ - Mask = ~((1 << (8 - (EndX % 8))) - 1); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, Mask); + /* Set write mode two. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); - Video = (PUCHAR)vidmem + DestY * 80 + (EndX >> 3); - Src = MaskBits + (SizeY - (DestY - StartY)) * MaskPitch + (SizeX >> 3) - 1; - for (i = DestY; i < EndY; i++, Video+=80) - { - Src -= MaskPitch; - SrcValue = (Src[0] << (8 - Bits)); - (VOID)READ_REGISTER_UCHAR(Video); - WRITE_REGISTER_UCHAR(Video, SrcValue); - } - - /* Restore the default write masks. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x8); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xFF); - } - - /* Set write mode two. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 5); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 2); - - /* Select raster op replace. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 3); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0); + /* Select raster op replace. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 3); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0); } BOOL InitPointer(PPDEV ppdev) { - ULONG CursorWidth = 32, CursorHeight = 32; - ULONG PointerAttributesSize; - ULONG SavedMemSize; + ULONG CursorWidth = 32, CursorHeight = 32; + ULONG PointerAttributesSize; + ULONG SavedMemSize; - ppdev->xyHotSpot.x = 0; - ppdev->xyHotSpot.y = 0; + ppdev->xyHotSpot.x = 0; + ppdev->xyHotSpot.y = 0; - /* Determine the size of the pointer attributes */ - PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + - ((CursorWidth * CursorHeight * 2) >> 3); + /* Determine the size of the pointer attributes */ + PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + + ((CursorWidth * CursorHeight * 2) >> 3); - /* Allocate memory for pointer attributes */ - ppdev->pPointerAttributes = EngAllocMem(0, PointerAttributesSize, ALLOC_TAG); + /* Allocate memory for pointer attributes */ + ppdev->pPointerAttributes = EngAllocMem(0, PointerAttributesSize, ALLOC_TAG); - ppdev->pPointerAttributes->Flags = 0; /* FIXME: Do this right */ - ppdev->pPointerAttributes->Width = CursorWidth; - ppdev->pPointerAttributes->Height = CursorHeight; - ppdev->pPointerAttributes->WidthInBytes = CursorWidth >> 3; - ppdev->pPointerAttributes->Enable = 0; - ppdev->pPointerAttributes->Column = 0; - ppdev->pPointerAttributes->Row = 0; + ppdev->pPointerAttributes->Flags = 0; /* FIXME: Do this right */ + ppdev->pPointerAttributes->Width = CursorWidth; + ppdev->pPointerAttributes->Height = CursorHeight; + ppdev->pPointerAttributes->WidthInBytes = CursorWidth >> 3; + ppdev->pPointerAttributes->Enable = 0; + ppdev->pPointerAttributes->Column = 0; + ppdev->pPointerAttributes->Row = 0; - /* Allocate memory for the pixels behind the cursor */ - SavedMemSize = ((((CursorWidth + 7) & ~0x7) + 16) * CursorHeight) >> 3; - ppdev->ImageBehindCursor = VGADDI_AllocSavedScreenBits(SavedMemSize); + /* Allocate memory for the pixels behind the cursor */ + SavedMemSize = ((((CursorWidth + 7) & ~0x7) + 16) * CursorHeight) >> 3; + ppdev->ImageBehindCursor = VGADDI_AllocSavedScreenBits(SavedMemSize); - return(TRUE); + return TRUE; } VOID APIENTRY -DrvMovePointer(IN SURFOBJ* pso, - IN LONG x, - IN LONG y, - IN PRECTL prcl) +DrvMovePointer( + IN SURFOBJ* pso, + IN LONG x, + IN LONG y, + IN PRECTL prcl) { - PPDEV ppdev = (PPDEV)pso->dhpdev; + PPDEV ppdev = (PPDEV)pso->dhpdev; - VGADDI_HideCursor(ppdev); + VGADDI_HideCursor(ppdev); - if(x != -1) - { - ppdev->pPointerAttributes->Column = x; - ppdev->pPointerAttributes->Row = y; + if(x != -1) + { + ppdev->pPointerAttributes->Column = x; + ppdev->pPointerAttributes->Row = y; - VGADDI_ShowCursor(ppdev, prcl); - } + VGADDI_ShowCursor(ppdev, prcl); + } } ULONG APIENTRY -DrvSetPointerShape(SURFOBJ* pso, - SURFOBJ* psoMask, - SURFOBJ* psoColor, - XLATEOBJ* pxlo, - LONG xHot, - LONG yHot, - LONG x, - LONG y, - PRECTL prcl, - ULONG fl) +DrvSetPointerShape( + IN SURFOBJ* pso, + IN SURFOBJ* psoMask, + IN SURFOBJ* psoColor, + IN XLATEOBJ* pxlo, + IN LONG xHot, + IN LONG yHot, + IN LONG x, + IN LONG y, + IN PRECTL prcl, + IN ULONG fl) { - PPDEV ppdev = (PPDEV)pso->dhpdev; - ULONG NewWidth, NewHeight; - PUCHAR Src, Dest; - ULONG i; + PPDEV ppdev = (PPDEV)pso->dhpdev; + ULONG NewWidth, NewHeight; + PUCHAR Src, Dest; + ULONG i; - if (! psoMask) + if (!psoMask) + return SPS_DECLINE; + + /* Hide the cursor */ + VGADDI_HideCursor(ppdev); + + NewWidth = abs(psoMask->lDelta) << 3; + NewHeight = (psoMask->cjBits / abs(psoMask->lDelta)) / 2; + + /* Reallocate the space for the cursor if necessary. */ + if (ppdev->pPointerAttributes->Width != NewWidth || + ppdev->pPointerAttributes->Height != NewHeight) { - return SPS_DECLINE; + ULONG PointerAttributesSize; + PVIDEO_POINTER_ATTRIBUTES NewPointerAttributes; + ULONG SavedMemSize; + + /* Determine the size of the pointer attributes */ + PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + + ((NewWidth * NewHeight * 2) >> 3); + + /* Allocate memory for pointer attributes */ + NewPointerAttributes = EngAllocMem(0, PointerAttributesSize, ALLOC_TAG); + *NewPointerAttributes = *ppdev->pPointerAttributes; + NewPointerAttributes->Width = NewWidth; + NewPointerAttributes->Height = NewHeight; + NewPointerAttributes->WidthInBytes = NewWidth >> 3; + EngFreeMem(ppdev->pPointerAttributes); + ppdev->pPointerAttributes = NewPointerAttributes; + + /* Reallocate the space for the saved bits. */ + VGADDI_FreeSavedScreenBits(ppdev->ImageBehindCursor); + SavedMemSize = ((((NewWidth + 7) & ~0x7) + 16) * NewHeight) >> 3; + ppdev->ImageBehindCursor = VGADDI_AllocSavedScreenBits(SavedMemSize); } - /* Hide the cursor */ - VGADDI_HideCursor(ppdev); - - NewWidth = abs(psoMask->lDelta) << 3; - NewHeight = (psoMask->cjBits / abs(psoMask->lDelta)) / 2; - - /* Reallocate the space for the cursor if necessary. */ - if (ppdev->pPointerAttributes->Width != NewWidth || - ppdev->pPointerAttributes->Height != NewHeight) + Src = (PUCHAR)psoMask->pvScan0; + /* Copy the new cursor in. */ + for (i = 0; i < (NewHeight * 2); i++) { - ULONG PointerAttributesSize; - PVIDEO_POINTER_ATTRIBUTES NewPointerAttributes; - ULONG SavedMemSize; - - /* Determine the size of the pointer attributes */ - PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + - ((NewWidth * NewHeight * 2) >> 3); - - /* Allocate memory for pointer attributes */ - NewPointerAttributes = EngAllocMem(0, PointerAttributesSize, ALLOC_TAG); - *NewPointerAttributes = *ppdev->pPointerAttributes; - NewPointerAttributes->Width = NewWidth; - NewPointerAttributes->Height = NewHeight; - NewPointerAttributes->WidthInBytes = NewWidth >> 3; - EngFreeMem(ppdev->pPointerAttributes); - ppdev->pPointerAttributes = NewPointerAttributes; - - /* Reallocate the space for the saved bits. */ - VGADDI_FreeSavedScreenBits(ppdev->ImageBehindCursor); - SavedMemSize = ((((NewWidth + 7) & ~0x7) + 16) * NewHeight) >> 3; - ppdev->ImageBehindCursor = VGADDI_AllocSavedScreenBits(SavedMemSize); + Dest = (PUCHAR)ppdev->pPointerAttributes->Pixels; + if (i >= NewHeight) + Dest += (((NewHeight * 3) - i - 1) * (NewWidth >> 3)); + else + Dest += ((NewHeight - i - 1) * (NewWidth >> 3)); + memcpy(Dest, Src, NewWidth >> 3); + Src += psoMask->lDelta; } - Src = (PUCHAR)psoMask->pvScan0; - /* Copy the new cursor in. */ - for (i = 0; i < (NewHeight * 2); i++) + /* Set the new cursor position */ + ppdev->xyHotSpot.x = xHot; + ppdev->xyHotSpot.y = yHot; + + if(x != -1) { - Dest = (PUCHAR)ppdev->pPointerAttributes->Pixels; - if (i >= NewHeight) - { - Dest += (((NewHeight * 3) - i - 1) * (NewWidth >> 3)); - } - else - { - Dest += ((NewHeight - i - 1) * (NewWidth >> 3)); - } - memcpy(Dest, Src, NewWidth >> 3); - Src += psoMask->lDelta; + ppdev->pPointerAttributes->Column = x; + ppdev->pPointerAttributes->Row = y; + + /* show the cursor */ + VGADDI_ShowCursor(ppdev, prcl); } - /* Set the new cursor position */ - ppdev->xyHotSpot.x = xHot; - ppdev->xyHotSpot.y = yHot; - - if(x != -1) - { - ppdev->pPointerAttributes->Column = x; - ppdev->pPointerAttributes->Row = y; - - /* show the cursor */ - VGADDI_ShowCursor(ppdev, prcl); - } - - return SPS_ACCEPT_EXCLUDE; + return SPS_ACCEPT_EXCLUDE; } static VOID FASTCALL -VGADDI_ComputePointerRect(PPDEV ppdev, LONG X, LONG Y, PRECTL Rect) +VGADDI_ComputePointerRect( + IN PPDEV ppdev, + IN LONG X, + IN LONG Y, + IN PRECTL Rect) { - ULONG SizeX, SizeY; + ULONG SizeX, SizeY; - SizeX = min(((X + (LONG)ppdev->pPointerAttributes->Width) + 7) & ~0x7, ppdev->sizeSurf.cx); - SizeX -= (X & ~0x7); - SizeY = min((LONG)ppdev->pPointerAttributes->Height, ppdev->sizeSurf.cy - Y); + SizeX = min(((X + (LONG)ppdev->pPointerAttributes->Width) + 7) & ~0x7, ppdev->sizeSurf.cx); + SizeX -= (X & ~0x7); + SizeY = min((LONG)ppdev->pPointerAttributes->Height, ppdev->sizeSurf.cy - Y); - Rect->left = max(X, 0) & ~0x7; - Rect->top = max(Y, 0); - Rect->right = Rect->left + SizeX; - Rect->bottom = Rect->top + SizeY; + Rect->left = max(X, 0) & ~0x7; + Rect->top = max(Y, 0); + Rect->right = Rect->left + SizeX; + Rect->bottom = Rect->top + SizeY; } static VOID VGADDI_HideCursor(PPDEV ppdev) { - if(ppdev->pPointerAttributes->Enable) - { - LONG cx, cy; - RECTL Rect; + if(ppdev->pPointerAttributes->Enable) + { + LONG cx, cy; + RECTL Rect; - ppdev->pPointerAttributes->Enable = 0; + ppdev->pPointerAttributes->Enable = 0; - cx = ppdev->pPointerAttributes->Column - ppdev->xyHotSpot.x; - cy = ppdev->pPointerAttributes->Row - ppdev->xyHotSpot.y; + cx = ppdev->pPointerAttributes->Column - ppdev->xyHotSpot.x; + cy = ppdev->pPointerAttributes->Row - ppdev->xyHotSpot.y; - VGADDI_ComputePointerRect(ppdev, cx, cy, &Rect); + VGADDI_ComputePointerRect(ppdev, cx, cy, &Rect); - /* Display what was behind cursor */ - VGADDI_BltFromSavedScreenBits(Rect.left, - Rect.top, - ppdev->ImageBehindCursor, - Rect.right - Rect.left, - Rect.bottom - Rect.top); - } + /* Display what was behind cursor */ + VGADDI_BltFromSavedScreenBits(Rect.left, + Rect.top, + ppdev->ImageBehindCursor, + Rect.right - Rect.left, + Rect.bottom - Rect.top); + } } static VOID VGADDI_ShowCursor(PPDEV ppdev, PRECTL prcl) { - LONG cx, cy; - PUCHAR AndMask, XorMask; - ULONG SizeX, SizeY; - RECTL Rect; + LONG cx, cy; + PUCHAR AndMask, XorMask; + ULONG SizeX, SizeY; + RECTL Rect; - if(ppdev->pPointerAttributes->Enable) - { - return; - } - /* Mark the cursor as currently displayed. */ - ppdev->pPointerAttributes->Enable = 1; + if(ppdev->pPointerAttributes->Enable) + return; - cx = ppdev->pPointerAttributes->Column - ppdev->xyHotSpot.x; - cy = ppdev->pPointerAttributes->Row - ppdev->xyHotSpot.y; + /* Mark the cursor as currently displayed. */ + ppdev->pPointerAttributes->Enable = 1; - /* Capture pixels behind the cursor */ - VGADDI_ComputePointerRect(ppdev, cx, cy, &Rect); + cx = ppdev->pPointerAttributes->Column - ppdev->xyHotSpot.x; + cy = ppdev->pPointerAttributes->Row - ppdev->xyHotSpot.y; - VGADDI_BltToSavedScreenBits(ppdev->ImageBehindCursor, - Rect.left, - Rect.top, - Rect.right - Rect.left, - Rect.bottom - Rect.top); + /* Capture pixels behind the cursor */ + VGADDI_ComputePointerRect(ppdev, cx, cy, &Rect); - /* Display the cursor. */ - SizeX = min((LONG)ppdev->pPointerAttributes->Width, ppdev->sizeSurf.cx - cx); - SizeY = min((LONG)ppdev->pPointerAttributes->Height, ppdev->sizeSurf.cy - cy); - AndMask = ppdev->pPointerAttributes->Pixels + - (ppdev->pPointerAttributes->Height - SizeY) * ppdev->pPointerAttributes->WidthInBytes; - VGADDI_BltPointerToVGA(cx, - cy, - SizeX, - SizeY, - AndMask, - ppdev->pPointerAttributes->WidthInBytes, - VGA_AND); - XorMask = AndMask + - ppdev->pPointerAttributes->WidthInBytes * - ppdev->pPointerAttributes->Height; - VGADDI_BltPointerToVGA(cx, - cy, - SizeX, - SizeY, - XorMask, - ppdev->pPointerAttributes->WidthInBytes, - VGA_XOR); + VGADDI_BltToSavedScreenBits(ppdev->ImageBehindCursor, + Rect.left, + Rect.top, + Rect.right - Rect.left, + Rect.bottom - Rect.top); - if (NULL != prcl) - { - *prcl = Rect; - } + /* Display the cursor. */ + SizeX = min((LONG)ppdev->pPointerAttributes->Width, ppdev->sizeSurf.cx - cx); + SizeY = min((LONG)ppdev->pPointerAttributes->Height, ppdev->sizeSurf.cy - cy); + AndMask = ppdev->pPointerAttributes->Pixels + + (ppdev->pPointerAttributes->Height - SizeY) * ppdev->pPointerAttributes->WidthInBytes; + VGADDI_BltPointerToVGA(cx, + cy, + SizeX, + SizeY, + AndMask, + ppdev->pPointerAttributes->WidthInBytes, + VGA_AND); + XorMask = AndMask + + ppdev->pPointerAttributes->WidthInBytes * + ppdev->pPointerAttributes->Height; + VGADDI_BltPointerToVGA(cx, + cy, + SizeX, + SizeY, + XorMask, + ppdev->pPointerAttributes->WidthInBytes, + VGA_XOR); + + if (NULL != prcl) + *prcl = Rect; } diff --git a/reactos/drivers/video/displays/vga/objects/screen.c b/reactos/drivers/video/displays/vga/objects/screen.c index d15da46bc8c..1f5bb5534f4 100644 --- a/reactos/drivers/video/displays/vga/objects/screen.c +++ b/reactos/drivers/video/displays/vga/objects/screen.c @@ -1,190 +1,203 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/screen.c + * PURPOSE: + * PROGRAMMERS: + */ + #include "../vgaddi.h" #include "../vgavideo/vgavideo.h" static WORD PaletteBuffer[] = { - 16, 0, // 16 entries, start with 0 - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 + 16, 0, // 16 entries, start with 0 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; static BYTE ColorBuffer[] = { - 16, // 16 entries - 0, 0, - 0, // start with 0 - 0x00, 0x00, 0x00, 0x00, // black - 0x2A, 0x00, 0x15, 0x00, // red - 0x00, 0x2A, 0x15, 0x00, // green - 0x2A, 0x2A, 0x15, 0x00, // brown - 0x00, 0x00, 0x2A, 0x00, // blue - 0x2A, 0x15, 0x2A, 0x00, // magenta - 0x15, 0x2A, 0x2A, 0x00, // cyan - 0x21, 0x22, 0x23, 0x00, // dark gray - 0x30, 0x31, 0x32, 0x00, // light gray - 0x3F, 0x00, 0x00, 0x00, // bright red - 0x00, 0x3F, 0x00, 0x00, // bright green - 0x3F, 0x3F, 0x00, 0x00, // bright yellow - 0x00, 0x00, 0x3F, 0x00, // bright blue - 0x3F, 0x00, 0x3F, 0x00, // bright magenta - 0x00, 0x3F, 0x3F, 0x00, // bright cyan - 0x3F, 0x3F, 0x3F, 0x00 // bright white + 16, // 16 entries + 0, 0, + 0, // start with 0 + 0x00, 0x00, 0x00, 0x00, // black + 0x2A, 0x00, 0x15, 0x00, // red + 0x00, 0x2A, 0x15, 0x00, // green + 0x2A, 0x2A, 0x15, 0x00, // brown + 0x00, 0x00, 0x2A, 0x00, // blue + 0x2A, 0x15, 0x2A, 0x00, // magenta + 0x15, 0x2A, 0x2A, 0x00, // cyan + 0x21, 0x22, 0x23, 0x00, // dark gray + 0x30, 0x31, 0x32, 0x00, // light gray + 0x3F, 0x00, 0x00, 0x00, // bright red + 0x00, 0x3F, 0x00, 0x00, // bright green + 0x3F, 0x3F, 0x00, 0x00, // bright yellow + 0x00, 0x00, 0x3F, 0x00, // bright blue + 0x3F, 0x00, 0x3F, 0x00, // bright magenta + 0x00, 0x3F, 0x3F, 0x00, // bright cyan + 0x3F, 0x3F, 0x3F, 0x00 // bright white }; -DWORD getAvailableModes(HANDLE Driver, - PVIDEO_MODE_INFORMATION *modeInformation, - DWORD *ModeSize) +DWORD getAvailableModes( + IN HANDLE Driver, + OUT PVIDEO_MODE_INFORMATION *modeInformation, + OUT DWORD *ModeSize) { - ULONG Temp; - VIDEO_NUM_MODES modes; - PVIDEO_MODE_INFORMATION VideoTemp; - - // get number of modes supported - if (EngDeviceIoControl(Driver, - IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES, - NULL, - 0, - &modes, - sizeof(VIDEO_NUM_MODES), - &Temp)) - { - // get modes failed - return(0); - } - - *ModeSize = modes.ModeInformationLength; - - // allocate buffer for the mini-port to write the modes in - *modeInformation = (PVIDEO_MODE_INFORMATION) - EngAllocMem(0, modes.NumModes * - modes.ModeInformationLength, ALLOC_TAG); - - if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL) - { - // couldn't allocate buffer - return 0; - } - - // Ask the mini-port to fill in the available modes. - if (EngDeviceIoControl(Driver, - IOCTL_VIDEO_QUERY_AVAIL_MODES, - NULL, - 0, - *modeInformation, - modes.NumModes * modes.ModeInformationLength, - &Temp)) - { - // failed to query modes - EngFreeMem(*modeInformation); - *modeInformation = (PVIDEO_MODE_INFORMATION) NULL; - - return(0); - } - - // Which modes supported by miniport driver are also suppoted by us, the - // display driver - - Temp = modes.NumModes; - VideoTemp = *modeInformation; - - // Reject mode if it's not 4 planes or not graphic or not 1 bits per pel - while (Temp--) - { - if ((VideoTemp->NumberOfPlanes != 4 ) || - !(VideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) || - (VideoTemp->BitsPerPlane != 1) || - BROKEN_RASTERS(VideoTemp->ScreenStride, VideoTemp->VisScreenHeight)) + ULONG Temp; + VIDEO_NUM_MODES modes; + PVIDEO_MODE_INFORMATION VideoTemp; + /* get number of modes supported */ + if (EngDeviceIoControl(Driver, + IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES, + NULL, + 0, + &modes, + sizeof(VIDEO_NUM_MODES), + &Temp)) { - VideoTemp->Length = 0; + /* get modes failed */ + return 0; } - VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + modes.ModeInformationLength); - } + *ModeSize = modes.ModeInformationLength; - return modes.NumModes; + /* allocate buffer for the mini-port to write the modes in */ + *modeInformation = (PVIDEO_MODE_INFORMATION) + EngAllocMem(0, modes.NumModes * + modes.ModeInformationLength, ALLOC_TAG); + + if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL) + { + /* couldn't allocate buffer */ + return 0; + } + + /* Ask the mini-port to fill in the available modes. */ + if (EngDeviceIoControl(Driver, + IOCTL_VIDEO_QUERY_AVAIL_MODES, + NULL, + 0, + *modeInformation, + modes.NumModes * modes.ModeInformationLength, + &Temp)) + { + /* failed to query modes */ + EngFreeMem(*modeInformation); + *modeInformation = (PVIDEO_MODE_INFORMATION) NULL; + + return 0; + } + + /* Which modes supported by miniport driver are also suppoted by us, the + * display driver */ + + Temp = modes.NumModes; + VideoTemp = *modeInformation; + + /* Reject mode if it's not 4 planes or not graphic or not 1 bits per pel */ + while (Temp--) + { + if ((VideoTemp->NumberOfPlanes != 4 ) || + !(VideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) || + (VideoTemp->BitsPerPlane != 1) || + BROKEN_RASTERS(VideoTemp->ScreenStride, VideoTemp->VisScreenHeight)) + { + VideoTemp->Length = 0; + } + + VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + modes.ModeInformationLength); + } + + return modes.NumModes; } BOOL DeinitVGA(PPDEV ppdev) { - VIDEO_MEMORY VideoMemory; - ULONG ReturnedDataLength; + VIDEO_MEMORY VideoMemory; + ULONG ReturnedDataLength; - VideoMemory.RequestedVirtualAddress = (PVOID)ppdev->fbScreen; + VideoMemory.RequestedVirtualAddress = (PVOID)ppdev->fbScreen; - if (EngDeviceIoControl(ppdev->KMDriver, - IOCTL_VIDEO_UNMAP_VIDEO_MEMORY, - (PVOID)&VideoMemory, - sizeof(VIDEO_MEMORY), - NULL, - 0, - &ReturnedDataLength)) + if (EngDeviceIoControl(ppdev->KMDriver, + IOCTL_VIDEO_UNMAP_VIDEO_MEMORY, + (PVOID)&VideoMemory, + sizeof(VIDEO_MEMORY), + NULL, + 0, + &ReturnedDataLength)) { - DbgPrint("Failed to unmap video memory.\n"); - DbgBreakPoint(); - return(FALSE); + //DPRINT1("Failed to unmap video memory.\n"); + DbgBreakPoint(); + return FALSE; } - return(TRUE); + return TRUE; } BOOL InitVGA(PPDEV ppdev, BOOL bFirst) { - ULONG ReturnedDataLength; - VIDEO_MEMORY VideoMemory; - VIDEO_MEMORY_INFORMATION VideoMemoryInfo; + ULONG ReturnedDataLength; + VIDEO_MEMORY VideoMemory; + VIDEO_MEMORY_INFORMATION VideoMemoryInfo; - ppdev->sizeSurf.cx = 640; - ppdev->sizeSurf.cy = 480; - ppdev->ModeNum = 12; + ppdev->sizeSurf.cx = 640; + ppdev->sizeSurf.cy = 480; + ppdev->ModeNum = 12; - // Set the mode that was requested - if (EngDeviceIoControl(ppdev->KMDriver, - IOCTL_VIDEO_SET_CURRENT_MODE, - &ppdev->ModeNum, - sizeof(VIDEO_MODE), - NULL, - 0, - &ReturnedDataLength)) { - return(FALSE); - } + /* Set the mode that was requested */ + if (EngDeviceIoControl(ppdev->KMDriver, + IOCTL_VIDEO_SET_CURRENT_MODE, + &ppdev->ModeNum, + sizeof(VIDEO_MODE), + NULL, + 0, + &ReturnedDataLength)) + { + return FALSE; + } - // set up internal palette - if (EngDeviceIoControl(ppdev->KMDriver, - IOCTL_VIDEO_SET_PALETTE_REGISTERS, - (PVOID) PaletteBuffer, - sizeof (PaletteBuffer), - NULL, - 0, - &ReturnedDataLength)) { - return(FALSE); - } + /* set up internal palette */ + if (EngDeviceIoControl(ppdev->KMDriver, + IOCTL_VIDEO_SET_PALETTE_REGISTERS, + (PVOID) PaletteBuffer, + sizeof (PaletteBuffer), + NULL, + 0, + &ReturnedDataLength)) + { + return FALSE; + } - // set up the DAC - if (EngDeviceIoControl(ppdev->KMDriver, - IOCTL_VIDEO_SET_COLOR_REGISTERS, - (PVOID) ColorBuffer, - sizeof (ColorBuffer), - NULL, - 0, - &ReturnedDataLength)) { - return(FALSE); - } + /* set up the DAC */ + if (EngDeviceIoControl(ppdev->KMDriver, + IOCTL_VIDEO_SET_COLOR_REGISTERS, + (PVOID) ColorBuffer, + sizeof (ColorBuffer), + NULL, + 0, + &ReturnedDataLength)) + { + return FALSE; + } - if (bFirst) { - // map video memory into virtual memory - VideoMemory.RequestedVirtualAddress = NULL; + if (bFirst) + { + /* map video memory into virtual memory */ + VideoMemory.RequestedVirtualAddress = NULL; - if (EngDeviceIoControl(ppdev->KMDriver, - IOCTL_VIDEO_MAP_VIDEO_MEMORY, - (PVOID) &VideoMemory, - sizeof (VIDEO_MEMORY), - (PVOID) &VideoMemoryInfo, - sizeof (VideoMemoryInfo), - &ReturnedDataLength)) { - // Failed to map to virtual memory - return (FALSE); - } + if (EngDeviceIoControl(ppdev->KMDriver, + IOCTL_VIDEO_MAP_VIDEO_MEMORY, + (PVOID) &VideoMemory, + sizeof (VIDEO_MEMORY), + (PVOID) &VideoMemoryInfo, + sizeof (VideoMemoryInfo), + &ReturnedDataLength)) + { + /* Failed to map to virtual memory */ + return FALSE; + } - ppdev->fbScreen = VideoMemoryInfo.FrameBufferBase; - vidmem = (PUCHAR)ppdev->fbScreen; - } + ppdev->fbScreen = VideoMemoryInfo.FrameBufferBase; + vidmem = (PUCHAR)ppdev->fbScreen; + } - return TRUE; + return TRUE; } diff --git a/reactos/drivers/video/displays/vga/objects/transblt.c b/reactos/drivers/video/displays/vga/objects/transblt.c index c4cb87e1db3..e1dfe75291d 100644 --- a/reactos/drivers/video/displays/vga/objects/transblt.c +++ b/reactos/drivers/video/displays/vga/objects/transblt.c @@ -1,3 +1,11 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/objects/transblt.c + * PURPOSE: + * PROGRAMMERS: + */ + #include "../vgaddi.h" #include "../vgavideo/vgavideo.h" #include "brush.h" @@ -7,28 +15,29 @@ #include BOOL APIENTRY -DrvTransparentBlt(SURFOBJ* Dest, - SURFOBJ* Source, - CLIPOBJ* Clip, - XLATEOBJ* ColorTranslation, - RECTL* DestRect, - RECTL* SourceRect, - ULONG TransparentColor, - ULONG Reserved) +DrvTransparentBlt( + IN SURFOBJ* Dest, + IN SURFOBJ* Source, + IN CLIPOBJ* Clip, + IN XLATEOBJ* ColorTranslation, + IN RECTL* DestRect, + IN RECTL* SourceRect, + IN ULONG TransparentColor, + IN ULONG Reserved) { - LONG dx, dy, sx, sy; + LONG dx, dy, sx, sy; - dx = abs(DestRect->right - DestRect->left); - dy = abs(DestRect->bottom - DestRect->top); + dx = abs(DestRect->right - DestRect->left); + dy = abs(DestRect->bottom - DestRect->top); - sx = abs(SourceRect->right - SourceRect->left); - sy = abs(SourceRect->bottom - SourceRect->top); + sx = abs(SourceRect->right - SourceRect->left); + sy = abs(SourceRect->bottom - SourceRect->top); - if(sxleft, DestRect->top, dx, dy, Source->pvScan0, Source->lDelta, TransparentColor); + /* FIXME: adjust using SourceRect */ + DIB_TransparentBltToVGA(DestRect->left, DestRect->top, dx, dy, Source->pvScan0, Source->lDelta, TransparentColor); - return TRUE; + return TRUE; } diff --git a/reactos/drivers/video/displays/vga/vgaddi.def b/reactos/drivers/video/displays/vga/vgaddi.def index baca733148a..2f98d49c250 100644 --- a/reactos/drivers/video/displays/vga/vgaddi.def +++ b/reactos/drivers/video/displays/vga/vgaddi.def @@ -1,11 +1,4 @@ -; $Id: vgaddi.def 26978 2007-06-03 16:45:34Z greatlrd $ -; ; vgaddi.def -; -; ReactOS Operating System -; -; From Anders Norlander's w32api-0.1.5 vgaddi.def. -; LIBRARY vgaddi.dll EXPORTS DrvEnableDriver@12 diff --git a/reactos/drivers/video/displays/vga/vgavideo/vgavideo.c b/reactos/drivers/video/displays/vga/vgavideo/vgavideo.c index 3ad965fcf8f..011c6b1d641 100644 --- a/reactos/drivers/video/displays/vga/vgavideo/vgavideo.c +++ b/reactos/drivers/video/displays/vga/vgavideo/vgavideo.c @@ -1,3 +1,11 @@ +/* + * PROJECT: ReactOS VGA display driver + * LICENSE: GPL - See COPYING in the top level directory + * FILE: drivers/video/displays/vga/vgavideo/vgavideo.c + * PURPOSE: + * PROGRAMMERS: + */ + #define _WINBASE_ #define _WINDOWS_H #include @@ -35,522 +43,470 @@ static unsigned char rightMask; #define READ_REGISTER_UCHAR(p) (*((volatile UCHAR *)(p))) #define WRITE_REGISTER_UCHAR(p,c) (*((volatile CHAR *)(p))) = (c) - -/*int mod(int num, int denom) +UCHAR bytesPerPixel(ULONG Format) { - div_t dvt = div(num, denom); - return dvt.rem; -}*/ + /* This function is taken from /subsys/win32k/eng/surface.c + * FIXME: GDI bitmaps are supposed to be pixel-packed. Right now if the + * pixel size if < 1 byte we expand it to 1 byte for simplicities sake */ -BYTE bytesPerPixel(ULONG Format) -{ - // This function is taken from /subsys/win32k/eng/surface.c - // FIXME: GDI bitmaps are supposed to be pixel-packed. Right now if the - // pixel size if < 1 byte we expand it to 1 byte for simplicities sake + switch (Format) + { + case BMF_1BPP: + return 1; - switch ( Format ) - { - case BMF_1BPP: - return 1; + case BMF_4BPP: + case BMF_4RLE: + return 1; - case BMF_4BPP: - case BMF_4RLE: - return 1; + case BMF_8BPP: + case BMF_8RLE: + return 1; - case BMF_8BPP: - case BMF_8RLE: - return 1; + case BMF_16BPP: + return 2; - case BMF_16BPP: - return 2; + case BMF_24BPP: + return 3; - case BMF_24BPP: - return 3; + case BMF_32BPP: + return 4; - case BMF_32BPP: - return 4; - - default: - return 0; - } + default: + return 0; + } } VOID vgaPreCalc() { - ULONG j; + ULONG j; - startmasks[0] = 255; - startmasks[1] = 1; - startmasks[2] = 3; - startmasks[3] = 7; - startmasks[4] = 15; - startmasks[5] = 31; - startmasks[6] = 63; - startmasks[7] = 127; + startmasks[0] = 255; + startmasks[1] = 1; + startmasks[2] = 3; + startmasks[3] = 7; + startmasks[4] = 15; + startmasks[5] = 31; + startmasks[6] = 63; + startmasks[7] = 127; - endmasks[0] = 0; - endmasks[1] = 128; - endmasks[2] = 192; - endmasks[3] = 224; - endmasks[4] = 240; - endmasks[5] = 248; - endmasks[6] = 252; - endmasks[7] = 254; + endmasks[0] = 0; + endmasks[1] = 128; + endmasks[2] = 192; + endmasks[3] = 224; + endmasks[4] = 240; + endmasks[5] = 248; + endmasks[6] = 252; + endmasks[7] = 254; - for(j=0; j<80; j++) - { - maskbit[j*8] = 128; - maskbit[j*8+1] = 64; - maskbit[j*8+2] = 32; - maskbit[j*8+3] = 16; - maskbit[j*8+4] = 8; - maskbit[j*8+5] = 4; - maskbit[j*8+6] = 2; - maskbit[j*8+7] = 1; - - bit8[j*8] = 7; - bit8[j*8+1] = 6; - bit8[j*8+2] = 5; - bit8[j*8+3] = 4; - bit8[j*8+4] = 3; - bit8[j*8+5] = 2; - bit8[j*8+6] = 1; - bit8[j*8+7] = 0; - } - for(j=0; j<480; j++) - { - y80[j] = j*80; - } - for(j=0; j<640; j++) - { - xconv[j] = j >> 3; - } - - for (j = 0; j < 256; j++) + for (j = 0; j < 80; j++) { - PreCalcReverseByte[j] = - (((j >> 0) & 0x1) << 7) | - (((j >> 1) & 0x1) << 6) | - (((j >> 2) & 0x1) << 5) | - (((j >> 3) & 0x1) << 4) | - (((j >> 4) & 0x1) << 3) | - (((j >> 5) & 0x1) << 2) | - (((j >> 6) & 0x1) << 1) | - (((j >> 7) & 0x1) << 0); + maskbit[j*8] = 128; + maskbit[j*8+1] = 64; + maskbit[j*8+2] = 32; + maskbit[j*8+3] = 16; + maskbit[j*8+4] = 8; + maskbit[j*8+5] = 4; + maskbit[j*8+6] = 2; + maskbit[j*8+7] = 1; + + bit8[j*8] = 7; + bit8[j*8+1] = 6; + bit8[j*8+2] = 5; + bit8[j*8+3] = 4; + bit8[j*8+4] = 3; + bit8[j*8+5] = 2; + bit8[j*8+6] = 1; + bit8[j*8+7] = 0; + } + for (j = 0; j < SCREEN_Y; j++) + y80[j] = j*80; + for (j = 0; j < SCREEN_X; j++) + xconv[j] = j >> 3; + + for (j = 0; j < 256; j++) + { + PreCalcReverseByte[j] = + (((j >> 0) & 0x1) << 7) | + (((j >> 1) & 0x1) << 6) | + (((j >> 2) & 0x1) << 5) | + (((j >> 3) & 0x1) << 4) | + (((j >> 4) & 0x1) << 3) | + (((j >> 5) & 0x1) << 2) | + (((j >> 6) & 0x1) << 1) | + (((j >> 7) & 0x1) << 0); } - for (j = 0; j < 256; j++) + for (j = 0; j < 256; j++) { - UnpackPixel[j] = - (((j >> 0) & 0x1) << 4) | - (((j >> 1) & 0x1) << 0) | - (((j >> 2) & 0x1) << 12) | - (((j >> 3) & 0x1) << 8) | - (((j >> 4) & 0x1) << 20) | - (((j >> 5) & 0x1) << 16) | - (((j >> 6) & 0x1) << 28) | - (((j >> 7) & 0x1) << 24); + UnpackPixel[j] = + (((j >> 0) & 0x1) << 4) | + (((j >> 1) & 0x1) << 0) | + (((j >> 2) & 0x1) << 12) | + (((j >> 3) & 0x1) << 8) | + (((j >> 4) & 0x1) << 20) | + (((j >> 5) & 0x1) << 16) | + (((j >> 6) & 0x1) << 28) | + (((j >> 7) & 0x1) << 24); } } void get_masks(int x, int w) { - register int tmp; + register int tmp; - leftMask = rightMask = 0; - byteCounter = w; - /* right margin */ - tmp = (x+w) & 7; - if (tmp) { - byteCounter -= tmp; - rightMask = (unsigned char)(0xff00 >> tmp); - } - /* left margin */ - tmp = x & 7; - if (tmp) { - byteCounter -= (8 - tmp); - leftMask = (0xff >> tmp); - } - /* too small ? */ - if (byteCounter < 0) { - leftMask &= rightMask; - rightMask = 0; - byteCounter = 0; - } - byteCounter /= 8; + leftMask = rightMask = 0; + byteCounter = w; + /* right margin */ + tmp = (x+w) & 7; + if (tmp) + { + byteCounter -= tmp; + rightMask = (unsigned char)(0xff00 >> tmp); + } + /* left margin */ + tmp = x & 7; + if (tmp) + { + byteCounter -= (8 - tmp); + leftMask = (0xff >> tmp); + } + /* too small ? */ + if (byteCounter < 0) + { + leftMask &= rightMask; + rightMask = 0; + byteCounter = 0; + } + byteCounter /= 8; } VOID vgaPutPixel(INT x, INT y, UCHAR c) { - ULONG offset; - UCHAR a; + ULONG offset; + UCHAR a; - offset = xconv[x]+y80[y]; + offset = xconv[x]+y80[y]; - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); - WRITE_PORT_UCHAR((PUCHAR)GRA_D,maskbit[x]); + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); + WRITE_PORT_UCHAR((PUCHAR)GRA_D,maskbit[x]); - a = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_REGISTER_UCHAR(vidmem + offset, c); + a = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_REGISTER_UCHAR(vidmem + offset, c); } VOID vgaPutByte(INT x, INT y, UCHAR c) { - ULONG offset; + ULONG offset; - offset = xconv[x]+y80[y]; + offset = xconv[x]+y80[y]; - // Set the write mode - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); - WRITE_PORT_UCHAR((PUCHAR)GRA_D,0xff); + /* Set the write mode */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); + WRITE_PORT_UCHAR((PUCHAR)GRA_D,0xff); - WRITE_REGISTER_UCHAR(vidmem + offset, c); + WRITE_REGISTER_UCHAR(vidmem + offset, c); } -VOID vgaGetByte(ULONG offset, - UCHAR *b, UCHAR *g, - UCHAR *r, UCHAR *i) +VOID vgaGetByte( + IN ULONG offset, + OUT UCHAR *b, + OUT UCHAR *g, + OUT UCHAR *r, + OUT UCHAR *i) { - WRITE_PORT_USHORT((PUSHORT)GRA_I, 0x0304); - *i = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - *r = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x01); - *g = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - *b = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_PORT_USHORT((PUSHORT)GRA_I, 0x0304); + *i = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + *r = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x01); + *g = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + *b = READ_REGISTER_UCHAR(vidmem + offset); } -INT vgaGetPixel(INT x, INT y) +INT vgaGetPixel( + IN INT x, + IN INT y) { - UCHAR mask, b, g, r, i; - ULONG offset; + UCHAR mask, b, g, r, i; + ULONG offset; - offset = xconv[x]+y80[y]; - vgaGetByte(offset, &b, &g, &r, &i); + offset = xconv[x] + y80[y]; + vgaGetByte(offset, &b, &g, &r, &i); - mask=maskbit[x]; - b=b&mask; - g=g&mask; - r=r&mask; - i=i&mask; + mask = maskbit[x]; + b = b & mask; + g = g & mask; + r = r & mask; + i = i & mask; - mask=bit8[x]; - g=g>>mask; - b=b>>mask; - r=r>>mask; - i=i>>mask; + mask = bit8[x]; + g = g >> mask; + b = b >> mask; + r = r >> mask; + i = i >> mask; - return(b+2*g+4*r+8*i); + return (b + 2 * g + 4 * r + 8 * i); } BOOL vgaHLine(INT x, INT y, INT len, UCHAR c) { - UCHAR a; - ULONG pre1; - ULONG orgpre1, orgx, midpre1; - LONG ileftpix, imidpix, irightpix; + UCHAR a; + ULONG pre1; + ULONG orgpre1, orgx, midpre1; + LONG ileftpix, imidpix, irightpix; - orgx = x; + orgx = x; - /*if ( len < 8 ) - { - for (i = x; i < x+len; i++ ) - vgaPutPixel ( i, y, c ); + /*if ( len < 8 ) + { + for (i = x; i < x+len; i++ ) + vgaPutPixel ( i, y, c ); + + return TRUE; + }*/ + + /* Calculate the left mask pixels, middle bytes and right mask pixel */ + ileftpix = 7 - mod8(x-1); + irightpix = mod8(x+len); + imidpix = (len-ileftpix-irightpix) / 8; + + pre1 = xconv[(x-1)&~7] + y80[y]; + orgpre1=pre1; + + /* check for overlap ( very short line ) */ + if ( (ileftpix+irightpix) > len ) + { + int mask = startmasks[ileftpix] & endmasks[irightpix]; + /* Write left pixels */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D,mask); + + a = READ_REGISTER_UCHAR(vidmem + pre1); + WRITE_REGISTER_UCHAR(vidmem + pre1, c); + + return TRUE; + } + + /* Left */ + if ( ileftpix > 0 ) + { + /* Write left pixels */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D,startmasks[ileftpix]); + + a = READ_REGISTER_UCHAR(vidmem + pre1); + WRITE_REGISTER_UCHAR(vidmem + pre1, c); + + /* Prepare new x for the middle */ + x = orgx + 8; + } + + if ( imidpix > 0 ) + { + midpre1 = xconv[x] + y80[y]; + + /* Set mask to all pixels in byte */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xff); + memset(vidmem+midpre1, c, imidpix); // write middle pixels, no need to read in latch because of the width + } + + if ( irightpix > 0 ) + { + x = orgx + len - irightpix; + pre1 = xconv[x] + y80[y]; + + /* Write right pixels */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask bits + WRITE_PORT_UCHAR((PUCHAR)GRA_D, endmasks[irightpix]); + a = READ_REGISTER_UCHAR(vidmem + pre1); + WRITE_REGISTER_UCHAR(vidmem + pre1, c); + } return TRUE; - }*/ - - // Calculate the left mask pixels, middle bytes and right mask pixel - ileftpix = 7 - mod8(x-1); - irightpix = mod8(x+len); - imidpix = (len-ileftpix-irightpix) / 8; - - pre1 = xconv[(x-1)&~7] + y80[y]; - orgpre1=pre1; - - // check for overlap ( very short line ) - if ( (ileftpix+irightpix) > len ) - { - int mask = startmasks[ileftpix] & endmasks[irightpix]; - // Write left pixels - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D,mask); - - a = READ_REGISTER_UCHAR(vidmem + pre1); - WRITE_REGISTER_UCHAR(vidmem + pre1, c); - - return TRUE; - } - - // Left - if ( ileftpix > 0 ) - { - // Write left pixels - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D,startmasks[ileftpix]); - - a = READ_REGISTER_UCHAR(vidmem + pre1); - WRITE_REGISTER_UCHAR(vidmem + pre1, c); - - // Prepare new x for the middle - x = orgx + 8; - } - - if ( imidpix > 0 ) - { - midpre1 = xconv[x] + y80[y]; - - // Set mask to all pixels in byte - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0xff); - memset(vidmem+midpre1, c, imidpix); // write middle pixels, no need to read in latch because of the width - } - - if ( irightpix > 0 ) - { - x = orgx + len - irightpix; - pre1 = xconv[x] + y80[y]; - - // Write right pixels - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask bits - WRITE_PORT_UCHAR((PUCHAR)GRA_D, endmasks[irightpix]); - a = READ_REGISTER_UCHAR(vidmem + pre1); - WRITE_REGISTER_UCHAR(vidmem + pre1, c); - } - - return TRUE; } BOOL vgaVLine(INT x, INT y, INT len, UCHAR c) { - INT offset, i; - UCHAR a; + INT offset, i; + UCHAR a; - offset = xconv[x]+y80[y]; + offset = xconv[x]+y80[y]; #ifdef VGA_PERF - vgaSetBitMaskRegister ( maskbit[x] ); + vgaSetBitMaskRegister ( maskbit[x] ); #else - WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D,maskbit[x]); + WRITE_PORT_UCHAR((PUCHAR)GRA_I,0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D,maskbit[x]); #endif - for(i=y; ileft = max(prcSrc1->left, prcSrc2->left); - prcDst->right = min(prcSrc1->right, prcSrc2->right); + prcDst->left = max(prcSrc1->left, prcSrc2->left); + prcDst->right = min(prcSrc1->right, prcSrc2->right); - if (prcDst->left < prcDst->right) { - prcDst->top = max(prcSrc1->top, prcSrc2->top); - prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); + if (prcDst->left < prcDst->right) + { + prcDst->top = max(prcSrc1->top, prcSrc2->top); + prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); - if (prcDst->top < prcDst->bottom) - { - return TRUE; - } - } + if (prcDst->top < prcDst->bottom) + return TRUE; + } - *prcDst = rclEmpty; + *prcDst = rclEmpty; - return FALSE; + return FALSE; } void DIB_BltFromVGA(int x, int y, int w, int h, void *b, int Dest_lDelta) { - ULONG plane; - ULONG left = x >> 3; - ULONG shift = x - (x & ~0x7); - UCHAR pixel, nextpixel; - LONG rightcount; - INT i, j; - LONG stride = w >> 3; + ULONG plane; + ULONG left = x >> 3; + ULONG shift = x - (x & ~0x7); + UCHAR pixel, nextpixel; + LONG rightcount; + INT i, j; + LONG stride = w >> 3; - /* Calculate the number of rightmost bytes not in a dword block. */ - if (w >= 8) + /* Calculate the number of rightmost bytes not in a dword block. */ + if (w >= 8) { - rightcount = w % 8; + rightcount = w % 8; } - else + else { - stride = 0; - rightcount = w; + stride = 0; + rightcount = w; } - /* Reset the destination. */ - for (j = 0; j < h; j++) + /* Reset the destination. */ + for (j = 0; j < h; j++) + memset((PVOID)((ULONG_PTR)b + (j * Dest_lDelta)), 0, abs(Dest_lDelta)); + + for (plane = 0; plane < 4; plane++) { - memset((PVOID)((ULONG_PTR)b + (j * Dest_lDelta)), 0, abs(Dest_lDelta)); - } + PUCHAR dest = b; - for (plane = 0; plane < 4; plane++) - { - PUCHAR dest = b; + /* Select the plane we are reading in this iteration. */ + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); - /* Select the plane we are reading in this iteration. */ - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); - WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); + for (j = 0; j < h; j++) + { + PULONG destline = (PULONG)dest; + PUCHAR src = vidmem + (y + j) * SCREEN_STRIDE + left; + /* Read the data for one plane for an eight aligned pixel block. */ + nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src)]; + for (i = 0; i < stride; i++, src++, destline++) + { + /* Form the data for one plane for an aligned block in the destination. */ + pixel = nextpixel; + pixel >>= shift; - for (j = 0; j < h; j++) - { - PULONG destline = (PULONG)dest; - PUCHAR src = vidmem + (y + j) * SCREEN_STRIDE + left; - /* Read the data for one plane for an eight aligned pixel block. */ - nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src)]; - for (i = 0; i < stride; i++, src++, destline++) - { - /* Form the data for one plane for an aligned block in the destination. */ - pixel = nextpixel; - pixel >>= shift; + nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src + 1)]; + pixel |= (nextpixel << (8 - shift)); - nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src + 1)]; - pixel |= (nextpixel << (8 - shift)); + /* Expand the plane data to 'chunky' format and store. */ + *destline |= (UnpackPixel[pixel] << plane); + } + /* Handle any pixels not falling into a full block. */ + if (rightcount != 0) + { + ULONG row; - /* Expand the plane data to 'chunky' format and store. */ - *destline |= (UnpackPixel[pixel] << plane); - } - /* Handle any pixels not falling into a full block. */ - if (rightcount != 0) - { - ULONG row; + /* Form the data for a complete block. */ + pixel = nextpixel; + pixel >>= shift; - /* Form the data for a complete block. */ - pixel = nextpixel; - pixel >>= shift; + nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src + 1)]; + pixel |= (nextpixel << (8 - shift)); - nextpixel = PreCalcReverseByte[READ_REGISTER_UCHAR(src + 1)]; - pixel |= (nextpixel << (8 - shift)); + row = UnpackPixel[pixel] << plane; - row = UnpackPixel[pixel] << plane; - - /* Store the data for each pixel in the destination. */ - for (i = 0; i < rightcount; i++) - { - ((PUCHAR)destline)[i] |= (row & 0xFF); - row >>= 8; - } - } - dest += Dest_lDelta; - } + /* Store the data for each pixel in the destination. */ + for (i = 0; i < rightcount; i++) + { + ((PUCHAR)destline)[i] |= (row & 0xFF); + row >>= 8; + } + } + dest += Dest_lDelta; + } } #ifdef VGA_VERIFY - for (j = 0; j < h; j++) + for (j = 0; j < h; j++) { - for (i = 0; i < w; i+=2) - { - UCHAR c1, c2; - ULONG mask = (i < (w - 1)) ? 0xFF : 0xF0; + for (i = 0; i < w; i += 2) + { + UCHAR c1, c2; + ULONG mask = (i < (w - 1)) ? 0xFF : 0xF0; - c1 = (vgaGetPixel(x + i, y + j) << 4) | (vgaGetPixel(x + i + 1, y + j)); - c2 = ((PUCHAR)b)[(j * Dest_lDelta) + (i >> 1)]; - if ((c1 & mask) != (c2 & mask)) - { - __asm__("int $3\n\t" : /* no outputs */ : /* no inputs */); - } - } + c1 = (vgaGetPixel(x + i, y + j) << 4) | (vgaGetPixel(x + i + 1, y + j)); + c2 = ((PUCHAR)b)[(j * Dest_lDelta) + (i >> 1)]; + if ((c1 & mask) != (c2 & mask)) + DbgBreakPoint(); + } } #endif /* VGA_VERIFY */ } -#if 0 -void DIB_BltFromVGA(int x, int y, int w, int h, void *b, int Dest_lDelta) -// DIB blt from the VGA. -// For now we just do slow reads -- pixel by pixel, packing each one into the correct 4BPP format. -{ - PBYTE pb = b, opb = b; - BOOLEAN edgePixel = FALSE; - ULONG i, j; - ULONG x2 = x + w; - ULONG y2 = y + h; - BYTE b1, b2; - - // Check if the width is odd - if(mod2(w)>0) - { - edgePixel = TRUE; - x2 -= 1; - } - - for (j=y; j> 4); - offset += 80; - pb += Source_lDelta; - } - } - else - { - for (j = y; j < y2; j++) - { - a = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_REGISTER_UCHAR(vidmem + offset, *pb & 0x0f); - offset += 80; - pb += Source_lDelta; - } - } + if (StartMod == ((i - x) % 2)) + { + for (j = y; j < y2; j++) + { + a = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_REGISTER_UCHAR(vidmem + offset, (*pb & 0xf0) >> 4); + offset += 80; + pb += Source_lDelta; + } + } + else + { + for (j = y; j < y2; j++) + { + a = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_REGISTER_UCHAR(vidmem + offset, *pb & 0x0f); + offset += 80; + pb += Source_lDelta; + } + } - if (StartMod != ((i - x) % 2)) - { - opb++; - } + if (StartMod != ((i - x) % 2)) + opb++; } } @@ -558,471 +514,457 @@ void DIB_BltToVGA(int x, int y, int w, int h, void *b, int Source_lDelta, int St /* DIB blt to the VGA. */ void DIB_BltToVGAWithXlate(int x, int y, int w, int h, void *b, int Source_lDelta, XLATEOBJ* Xlate) { - PBYTE pb, opb = b; - ULONG i, j; - ULONG x2 = x + w; - ULONG y2 = y + h; - ULONG offset; - UCHAR a; + PUCHAR pb, opb = b; + ULONG i, j; + ULONG x2 = x + w; + ULONG y2 = y + h; + ULONG offset; + UCHAR a; - for (i = x; i < x2; i++) + for (i = x; i < x2; i++) { - pb = opb; - offset = xconv[i] + y80[y]; + pb = opb; + offset = xconv[i] + y80[y]; - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // set the mask - WRITE_PORT_UCHAR((PUCHAR)GRA_D, maskbit[i]); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // set the mask + WRITE_PORT_UCHAR((PUCHAR)GRA_D, maskbit[i]); - if (0 == ((i - x) % 2)) - { - for (j = y; j < y2; j++) - { - a = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_REGISTER_UCHAR(vidmem + offset, XLATEOBJ_iXlate(Xlate, (*pb & 0xf0) >> 4)); - offset += 80; - pb += Source_lDelta; - } - } - else - { - for (j = y; j < y2; j++) - { - a = READ_REGISTER_UCHAR(vidmem + offset); - WRITE_REGISTER_UCHAR(vidmem + offset, XLATEOBJ_iXlate(Xlate, *pb & 0x0f)); - offset += 80; - pb += Source_lDelta; - } - } + if (0 == ((i - x) % 2)) + { + for (j = y; j < y2; j++) + { + a = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_REGISTER_UCHAR(vidmem + offset, XLATEOBJ_iXlate(Xlate, (*pb & 0xf0) >> 4)); + offset += 80; + pb += Source_lDelta; + } + } + else + { + for (j = y; j < y2; j++) + { + a = READ_REGISTER_UCHAR(vidmem + offset); + WRITE_REGISTER_UCHAR(vidmem + offset, XLATEOBJ_iXlate(Xlate, *pb & 0x0f)); + offset += 80; + pb += Source_lDelta; + } + } - if (0 != ((i - x) % 2)) - { - opb++; - } + if (0 != ((i - x) % 2)) + opb++; } } +/* DIB blt to the VGA. + * For now we just do slow writes -- pixel by pixel, + * packing each one into the correct 4BPP format. */ void DIB_TransparentBltToVGA(int x, int y, int w, int h, void *b, int Source_lDelta, ULONG trans) -// DIB blt to the VGA. -// For now we just do slow writes -- pixel by pixel, packing each one into the correct 4BPP format. { - PBYTE pb = b, opb = b; - BOOLEAN edgePixel = FALSE; - ULONG i, j; - ULONG x2 = x + w; - ULONG y2 = y + h; - BYTE b1, b2; + PUCHAR pb = b, opb = b; + BOOLEAN edgePixel = FALSE; + ULONG i, j; + ULONG x2 = x + w; + ULONG y2 = y + h; + UCHAR b1, b2; - // Check if the width is odd - if(mod2(w)>0) - { - edgePixel = TRUE; - x2 -= 1; - } - - for (j=y; j 0) { - b1 = (*pb & 0xf0) >> 4; - b2 = *pb & 0x0f; - if(b1 != trans) vgaPutPixel(i, j, b1); - if(b2 != trans) vgaPutPixel(i+1, j, b2); - pb++; + edgePixel = TRUE; + x2 -= 1; } - if(edgePixel == TRUE) + for (j=y; j> 4; + b2 = *pb & 0x0f; + if(b1 != trans) vgaPutPixel(i, j, b1); + if(b2 != trans) vgaPutPixel(i+1, j, b2); + pb++; + } + + if (edgePixel == TRUE) + { + b1 = *pb; + if(b1 != trans) vgaPutPixel(x2, j, b1); + pb++; + } + + opb += Source_lDelta; + pb = opb; // new test code } - - opb += Source_lDelta; - pb = opb; // new test code - - } } // This algorithm goes from left to right, storing each 4BPP pixel // in an entire byte. void FASTCALL -vgaReadScan ( int x, int y, int w, void *b ) +vgaReadScan( int x, int y, int w, void *b ) { - unsigned char *vp, *vpP; - unsigned char data, mask, maskP; - unsigned char *bp; - unsigned char plane_mask; - int plane, i; + unsigned char *vp, *vpP; + unsigned char data, mask, maskP; + unsigned char *bp; + unsigned char plane_mask; + int plane, i; - ASSIGNVP4(x, y, vpP) - ASSIGNMK4(x, y, maskP) - get_masks(x, w); - WRITE_PORT_USHORT((PUSHORT)GRA_I, 0x0005); // read mode 0 - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); // read map select + ASSIGNVP4(x, y, vpP) + ASSIGNMK4(x, y, maskP) + get_masks(x, w); + WRITE_PORT_USHORT((PUSHORT)GRA_I, 0x0005); // read mode 0 + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); // read map select - memset ( b, 0, w ); + memset ( b, 0, w ); - for ( plane=0, plane_mask=1; plane < 4; plane++, plane_mask<<=1 ) - { - WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); // read map select - - vp = vpP; - bp = b; - if ( leftMask ) + for ( plane=0, plane_mask=1; plane < 4; plane++, plane_mask<<=1 ) { - mask = maskP; - data = *vp++; - do - { - if (data & mask) - *bp |= plane_mask; - bp++; - mask >>= 1; - } while (mask & leftMask); + WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); // read map select + vp = vpP; + bp = b; + if ( leftMask ) + { + mask = maskP; + data = *vp++; + do + { + if (data & mask) + *bp |= plane_mask; + bp++; + mask >>= 1; + } while (mask & leftMask); + } + if (byteCounter) + { + for (i=byteCounter; i>0; i--) + { + data = *vp++; + if (data & 0x80) *bp |= plane_mask; + bp++; + + if (data & 0x40) *bp |= plane_mask; + bp++; + if (data & 0x20) *bp |= plane_mask; + bp++; + if (data & 0x10) *bp |= plane_mask; + bp++; + if (data & 0x08) *bp |= plane_mask; + bp++; + if (data & 0x04) *bp |= plane_mask; + bp++; + if (data & 0x02) *bp |= plane_mask; + bp++; + if (data & 0x01) *bp |= plane_mask; + bp++; + } + } + if (rightMask) + { + mask = 0x80; + data = *vp; + do + { + if (data & mask) + *bp |= plane_mask; + bp++; + mask >>= 1; + } while (mask & rightMask); + } } - if (byteCounter) - { - for (i=byteCounter; i>0; i--) - { - data = *vp++; - if (data & 0x80) *bp |= plane_mask; - bp++; - if (data & 0x40) *bp |= plane_mask; - bp++; - if (data & 0x20) *bp |= plane_mask; - bp++; - if (data & 0x10) *bp |= plane_mask; - bp++; - if (data & 0x08) *bp |= plane_mask; - bp++; - if (data & 0x04) *bp |= plane_mask; - bp++; - if (data & 0x02) *bp |= plane_mask; - bp++; - if (data & 0x01) *bp |= plane_mask; - bp++; - } - } - if (rightMask) - { - mask = 0x80; - data = *vp; - do - { - if (data & mask) - *bp |= plane_mask; - bp++; - mask >>= 1; - } while (mask & rightMask); - } - } - - // We don't need this if the next call is a DFB blt to VGA (as in the case of moving the mouse pointer) - //WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 - //WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - //WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace - //WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); } -// This algorithm goes from left to right -// It stores each 4BPP pixel in an entire byte. +/* This algorithm goes from left to right + * It stores each 4BPP pixel in an entire byte. */ void FASTCALL vgaWriteScan ( int x, int y, int w, void *b ) { - unsigned char *bp; - unsigned char *vp; - unsigned char init_mask; - volatile unsigned char dummy; - int byte_per_line; - int i, j, off, init_off = x&7; + unsigned char *bp; + unsigned char *vp; + unsigned char init_mask; + volatile unsigned char dummy; + int byte_per_line; + int i, j, off, init_off = x&7; - bp = b; - ASSIGNVP4(x, y, vp) - ASSIGNMK4(x, y, init_mask) - byte_per_line = SCREEN_X >> 3; + bp = b; + ASSIGNVP4(x, y, vp) + ASSIGNMK4(x, y, init_mask) + byte_per_line = SCREEN_X >> 3; - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask - //DbgPrint("vgaWriteScan(%i,%i,%i...)\n",x,y,w); - for ( j = 0; j < 8; j++ ) - { - unsigned int mask = 0x80 >> j; - //DbgPrint("j=%i\n",j); - WRITE_PORT_UCHAR ( (PUCHAR)GRA_D, (unsigned char)mask ); - i = j - init_off; - off = 0; - if ( j < init_off ) - i += 8, off++; - while ( i < w ) + for ( j = 0; j < 8; j++) { - //DbgPrint("(%i)",i); - dummy = vp[off]; - //DbgPrint("."); - dummy = bp[i]; - //DbgPrint("."); - vp[off] = dummy; - //DbgPrint("."); - i += 8; - off++; - } - //DbgPrint("\n"); - } -} - -void DFB_BltFromVGA(int x, int y, int w, int h, void *b, int bw) - -// This algorithm goes from left to right, and inside that loop, top to bottom. -// It also stores each 4BPP pixel in an entire byte. -{ - unsigned char *vp, *vpY, *vpP; - unsigned char data, mask, maskP; - unsigned char *bp, *bpY; - unsigned char plane_mask; - int byte_per_line = SCREEN_X >> 3; - int plane, i, j; - - ASSIGNVP4(x, y, vpP) - ASSIGNMK4(x, y, maskP) - get_masks(x, w); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // read mode 0 - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); // read map select - - // clear buffer - bp=b; - for (j=h; j>0; j--) - { - memset(bp, 0, w); - bp += bw; - } - - for ( plane=0, plane_mask=1; plane < 4; plane++, plane_mask<<=1 ) - { - WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); // read map select - vpY = vpP; - bpY = b; - for ( j=h; j>0; j-- ) - { - vp = vpY; - bp = bpY; - if ( leftMask ) - { - mask = maskP; - data = *vp++; - do - { - if (data & mask) - *bp |= plane_mask; - bp++; - mask >>= 1; - } while (mask & leftMask); - - } - if (byteCounter) - { - for (i=byteCounter; i>0; i--) - { - data = *vp++; - if (data & 0x80) *bp |= plane_mask; - bp++; - if (data & 0x40) *bp |= plane_mask; - bp++; - if (data & 0x20) *bp |= plane_mask; - bp++; - if (data & 0x10) *bp |= plane_mask; - bp++; - if (data & 0x08) *bp |= plane_mask; - bp++; - if (data & 0x04) *bp |= plane_mask; - bp++; - if (data & 0x02) *bp |= plane_mask; - bp++; - if (data & 0x01) *bp |= plane_mask; - bp++; + unsigned int mask = 0x80 >> j; + WRITE_PORT_UCHAR ( (PUCHAR)GRA_D, (unsigned char)mask ); + i = j - init_off; + off = 0; + if (j < init_off) + i += 8, off++; + while (i < w) + { + dummy = vp[off]; + dummy = bp[i]; + vp[off] = dummy; + i += 8; + off++; } - } - if (rightMask) - { - mask = 0x80; - data = *vp; - do - { - if (data & mask) *bp |= plane_mask; - bp++; - mask >>= 1; - } while (mask & rightMask); - } - bpY += bw; - vpY += byte_per_line; } - } - - // We don't need this if the next call is a DFB blt to VGA (as in the case of moving the mouse pointer) - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); } +/* This algorithm goes from left to right, and inside that loop, top to bottom. + * It also stores each 4BPP pixel in an entire byte. */ +void DFB_BltFromVGA(int x, int y, int w, int h, void *b, int bw) +{ + unsigned char *vp, *vpY, *vpP; + unsigned char data, mask, maskP; + unsigned char *bp, *bpY; + unsigned char plane_mask; + int byte_per_line = SCREEN_X >> 3; + int plane, i, j; + + ASSIGNVP4(x, y, vpP) + ASSIGNMK4(x, y, maskP) + get_masks(x, w); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // read mode 0 + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x04); // read map select + + /* clear buffer */ + bp = b; + for (j = h; j > 0; j--) + { + memset(bp, 0, w); + bp += bw; + } + + for (plane = 0, plane_mask = 1; plane < 4; plane++, plane_mask <<= 1) + { + WRITE_PORT_UCHAR((PUCHAR)GRA_D, plane); // read map select + vpY = vpP; + bpY = b; + for (j = h; j > 0; j--) + { + vp = vpY; + bp = bpY; + if (leftMask) + { + mask = maskP; + data = *vp++; + do + { + if (data & mask) + *bp |= plane_mask; + bp++; + mask >>= 1; + } while (mask & leftMask); + } + if (byteCounter) + { + for (i=byteCounter; i>0; i--) + { + data = *vp++; + if (data & 0x80) *bp |= plane_mask; + bp++; + if (data & 0x40) *bp |= plane_mask; + bp++; + if (data & 0x20) *bp |= plane_mask; + bp++; + if (data & 0x10) *bp |= plane_mask; + bp++; + if (data & 0x08) *bp |= plane_mask; + bp++; + if (data & 0x04) *bp |= plane_mask; + bp++; + if (data & 0x02) *bp |= plane_mask; + bp++; + if (data & 0x01) *bp |= plane_mask; + bp++; + } + } + if (rightMask) + { + mask = 0x80; + data = *vp; + do + { + if (data & mask) *bp |= plane_mask; + bp++; + mask >>= 1; + } while (mask & rightMask); + } + bpY += bw; + vpY += byte_per_line; + } + } + + // We don't need this if the next call is a DFB blt to VGA (as in the case of moving the mouse pointer) + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); +} + +/* This algorithm goes from left to right, and inside that loop, top to bottom. + * It also stores each 4BPP pixel in an entire byte. */ void DFB_BltToVGA(int x, int y, int w, int h, void *b, int bw) - -// This algorithm goes from left to right, and inside that loop, top to bottom. -// It also stores each 4BPP pixel in an entire byte. { - unsigned char *bp, *bpX; - unsigned char *vp, *vpX; - unsigned char mask; - volatile unsigned char dummy; - int byte_per_line; - int i, j; + unsigned char *bp, *bpX; + unsigned char *vp, *vpX; + unsigned char mask; + volatile unsigned char dummy; + int byte_per_line; + int i, j; - bpX = b; - ASSIGNVP4(x, y, vpX) - ASSIGNMK4(x, y, mask) - byte_per_line = SCREEN_X >> 3; + bpX = b; + ASSIGNVP4(x, y, vpX) + ASSIGNMK4(x, y, mask) + byte_per_line = SCREEN_X >> 3; - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask - for (i=w; i>0; i--) - { - WRITE_PORT_UCHAR((PUCHAR)GRA_D, mask); - bp = bpX; - vp = vpX; - for (j=h; j>0; j--) + for (i=w; i>0; i--) { - dummy = *vp; - *vp = *bp; - bp += bw; - vp += byte_per_line; + WRITE_PORT_UCHAR((PUCHAR)GRA_D, mask); + bp = bpX; + vp = vpX; + for (j = h; j > 0; j--) + { + dummy = *vp; + *vp = *bp; + bp += bw; + vp += byte_per_line; + } + bpX++; + if ((mask >>= 1) == 0) + { + vpX++; + mask = 0x80; + } } - bpX++; - if ((mask >>= 1) == 0) - { - vpX++; - mask = 0x80; - } - } } +/* This algorithm goes from goes from left to right, and inside that loop, top to bottom. + * It also stores each 4BPP pixel in an entire byte. */ void DFB_BltToVGA_Transparent(int x, int y, int w, int h, void *b, int bw, char Trans) - -// This algorithm goes from goes from left to right, and inside that loop, top to bottom. -// It also stores each 4BPP pixel in an entire byte. { - unsigned char *bp, *bpX; - unsigned char *vp, *vpX; - unsigned char mask; - volatile unsigned char dummy; - int byte_per_line; - int i, j; + unsigned char *bp, *bpX; + unsigned char *vp, *vpX; + unsigned char mask; + volatile unsigned char dummy; + int byte_per_line; + int i, j; - bpX = b; - ASSIGNVP4(x, y, vpX) - ASSIGNMK4(x, y, mask) - byte_per_line = SCREEN_X >> 3; + bpX = b; + ASSIGNVP4(x, y, vpX) + ASSIGNMK4(x, y, mask) + byte_per_line = SCREEN_X >> 3; - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace - WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); - WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x05); // write mode 2 + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x02); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x03); // replace + WRITE_PORT_UCHAR((PUCHAR)GRA_D, 0x00); + WRITE_PORT_UCHAR((PUCHAR)GRA_I, 0x08); // bit mask - for (i=w; i>0; i--) - { - WRITE_PORT_UCHAR((PUCHAR)GRA_D, mask); - bp = bpX; - vp = vpX; - for (j=h; j>0; j--) + for (i=w; i>0; i--) { - if (*bp != Trans) - { - dummy = *vp; - *vp = *bp; - } - bp += bw; - vp += byte_per_line; + WRITE_PORT_UCHAR((PUCHAR)GRA_D, mask); + bp = bpX; + vp = vpX; + for (j=h; j>0; j--) + { + if (*bp != Trans) + { + dummy = *vp; + *vp = *bp; + } + bp += bw; + vp += byte_per_line; + } + bpX++; + if ((mask >>= 1) == 0) + { + vpX++; + mask = 0x80; + } } - bpX++; - if ((mask >>= 1) == 0) - { - vpX++; - mask = 0x80; - } - } } +/* This algorithm converts a DFB into a DIB + * WARNING: This algorithm is buggy */ void DFB_BltToDIB(int x, int y, int w, int h, void *b, int bw, void *bdib, int dibw) - -// This algorithm converts a DFB into a DIB -// WARNING: This algorithm is buggy { - unsigned char *bp, *bpX, *dib, *dibTmp; - int i, j, dib_shift; + unsigned char *bp, *bpX, *dib, *dibTmp; + int i, j, dib_shift; - bpX = b; - dib = (unsigned char *)bdib + y * dibw + (x / 2); + bpX = b; + dib = (unsigned char *)bdib + y * dibw + (x / 2); - for (i=w; i>0; i--) { + for (i=w; i>0; i--) + { + /* determine the bit shift for the DIB pixel */ + dib_shift = mod2(w-i); + if(dib_shift > 0) + dib_shift = 4; + dibTmp = dib; - // determine the bit shift for the DIB pixel - dib_shift = mod2(w-i); - if(dib_shift > 0) dib_shift = 4; - dibTmp = dib; - - bp = bpX; - for (j=h; j>0; j--) { - *dibTmp = *bp << dib_shift | *(bp + 1); - dibTmp += dibw; - bp += bw; + bp = bpX; + for (j = h; j > 0; j--) + { + *dibTmp = *bp << dib_shift | *(bp + 1); + dibTmp += dibw; + bp += bw; + } + bpX++; + if(dib_shift == 0) + dib++; } - bpX++; - if(dib_shift == 0) dib++; - } } - +/* This algorithm converts a DIB into a DFB */ void DIB_BltToDFB(int x, int y, int w, int h, void *b, int bw, void *bdib, int dibw) - -// This algorithm converts a DIB into a DFB { - unsigned char *bp, *bpX, *dib, *dibTmp; - int i, j, dib_shift, dib_and; + unsigned char *bp, *bpX, *dib, *dibTmp; + int i, j, dib_shift, dib_and; - bpX = b; - dib = (unsigned char *)bdib + y * dibw + (x / 2); + bpX = b; + dib = (unsigned char *)bdib + y * dibw + (x / 2); - for (i=w; i>0; i--) { + for (i=w; i>0; i--) + { + /* determine the bit shift for the DIB pixel */ + dib_shift = mod2(w-i); + if(dib_shift > 0) + { + dib_shift = 0; + dib_and = 0x0f; + } + else + { + dib_shift = 4; + dib_and = 0xf0; + } - // determine the bit shift for the DIB pixel - dib_shift = mod2(w-i); - if(dib_shift > 0) { - dib_shift = 0; - dib_and = 0x0f; - } else { - dib_shift = 4; - dib_and = 0xf0; + dibTmp = dib; + bp = bpX; + + for (j=h; j>0; j--) + { + *bp = (*dibTmp & dib_and) >> dib_shift; + dibTmp += dibw; + bp += bw; + } + + bpX++; + if (dib_shift == 0) + dib++; } - - dibTmp = dib; - bp = bpX; - - for (j=h; j>0; j--) { - *bp = (*dibTmp & dib_and) >> dib_shift; - dibTmp += dibw; - bp += bw; - } - - bpX++; - if(dib_shift == 0) dib++; - } }