common.c File Reference

#include "precomp.h"

Include dependency graph for common.c:

Go to the source code of this file.

Functions
static VOID	BitBlt (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
static VOID	RleBitBlt (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_ PUCHAR Buffer)
VOID NTAPI	VidBufferToScreenBlt (_In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_ ULONG Delta)
VOID NTAPI	VidBitBlt (_In_ PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top)

Variables
const RGBQUAD	VidpDefaultPalette [BV_MAX_COLORS]

Function Documentation

BitBlt()

static VOID BitBlt ( _In_ ULONG  Left, _In_ ULONG  Top, _In_ ULONG  Width, _In_ ULONG  Height, _In_reads_bytes_(Delta *Height) PUCHAR  Buffer, _In_ ULONG  BitsPerPixel, _In_ ULONG  Delta  )

static

Definition at line 42 of file common.c.

{
    ULONG X, Y, Pixel;
    UCHAR Colors;
    PUCHAR InputBuffer;
    const ULONG Bottom = Top + Height;
    const ULONG Right = Left + Width;
 
    /* Check if the buffer isn't 4bpp */
    if (BitsPerPixel != 4)
    {
        /* FIXME: TODO */
        DbgPrint("Unhandled BitBlt\n"
                 "%lux%lu @ (%lu|%lu)\n"
                 "Bits Per Pixel %lu\n"
                 "Buffer: %p. Delta: %lu\n",
                 Width,
                 Height,
                 Left,
                 Top,
                 BitsPerPixel,
                 Buffer,
                 Delta);
        return;
    }
 
    PrepareForSetPixel();
 
    /* 4bpp blitting */
    for (Y = Top; Y < Bottom; ++Y)
    {
        InputBuffer = Buffer;
 
        for (X = Left, Pixel = 0;
             X < Right;
             ++X, ++Pixel)
        {
            if (Pixel % 2 == 0)
            {
                /* Extract colors at every two pixels */
                Colors = *InputBuffer++;
 
                SetPixel(X, Y, Colors >> 4);
            }
            else
            {
                SetPixel(X, Y, Colors & 0x0F);
            }
        }
 
        Buffer += Delta;
    }
}

Referenced by CMenuDeskBar::_OnPaint(), AboutDlgProc(), add_ruler_units(), alpha_blend_image(), ANIMATE_PaintFrame(), ANIMATE_TransparentBlt(), BitBltFromClipboard(), CDimmedWindow::Blt(), BltCard(), C1_DrawLabel(), C1_InvertButton(), C1_OnDraw(), CDimmedWindow::Capture(), CaptureScreen(), CardBlt(), CC_PaintColorGraph(), CC_PaintCross(), check_BitBlt_pixel(), check_bits(), cicChangeBitmapColor(), cicConvertBlackBKGBitmap(), cicCreateDisabledBitmap(), cicCreateMaskBmp(), cicCreateShadowMaskBmp(), cicDrawMaskBmpOnDC(), cicMirrorBitmap(), ClippedBitBlt(), ClockWndProc(), ColorKeyedMaskBlt(), COMCTL32_EnsureBitmapSize(), ConvertBitmapTo32Bpp(), CCicLibMenuItem::CreateBitmap(), CreateMDIMenuBitmap(), CreateStarBitmap(), ddraw_surface_update_frontbuffer(), device_load_logo(), RdpClientUI::Display_DrawGlyph(), RdpClientUI::Display_MemBlt(), RdpClientUI::Display_ScreenBlt(), RdpClientUI::Display_TriBlt(), RdpClientUI::DisplayWindowProc(), DoBlt(), CCanvasWindow::DoDraw(), Draw(), draw_graphics(), DrawCard(), DrawFace(), DrawGlyph(), DrawHorzCardStrip(), DrawIconOnOwnerDrawnButtons(), CUIFButton::DrawIconProc(), PictureButton::DrawItem(), DrawLeds(), DrawMine(), DrawProc(), DrawTileBitmap(), DrawVertCardStrip(), dup_bitmap(), EndBufferedPaint(), GeneralPageProc(), get_bitmap_info(), GetDiaogTextureBrush(), getSubImage(), Ghost_OnDraw(), GraphCtrl_AddPoint(), GraphCtrl_WndProc(), HEADER_DrawItem(), HelDdSurfBlt(), HelDdSurfLock(), HelDdSurfUnlock(), HEXEDIT_WM_PAINT(), HLPFILE_RtfAddTransparentBitmap(), ImageList_Add(), ImageList_AddMasked(), ImageList_BeginDrag(), ImageList_Copy(), imagelist_copy_images(), ImageList_DragMove(), ImageList_DragShowNolock(), ImageList_DrawIndirect(), ImageList_Duplicate(), ImageList_GetIcon(), IMAGELIST_InternalExpandBitmaps(), ImageList_Merge(), ImageList_Replace(), ImageList_ReplaceIcon(), Imm32DrawBitmap(), IntDrawState(), IntGetWindowBitmap(), IntGrayString(), LISTVIEW_Refresh(), LoadCardBitmapsFromLibrary(), MainWndProc(), mi_paint_rect(), CardRegion::MoveDragCardTo(), mstsc_WndProc(), NT5_DrawBaseBackground(), NT5_DrawLogoffIcon(), OLEPictureImpl_LoadWICSource(), CMainWindow::OnCommand(), OnDrawItem(), OnPaint(), CFullscreenWindow::OnPaint(), CMiniatureWindow::OnPaint(), CPaletteWindow::OnPaint(), CDownloaderProgress::OnPaint(), CBrandBand::OnPaint(), StartMenuRoot::Paint(), PaintBanner(), CardWindow::PaintCardRgn(), PaintCells(), PAINTING_DrawStateJam(), CAppScrnshotPreview::PaintOnDC(), PlayEnhMetaFileRecord(), PlayMetaFileRecord(), ProgressDlg::ProcessWindowMessage(), PROPSHEET_Paint(), putSubImage(), RosImageProc(), Run(), ScreenSaverProc(), show_image(), SIC_OverlayShortcutImage(), SkewDIB(), START_TEST(), StatusDialogProc(), StatusMessageWindowProc(), swapchain_gdi_frontbuffer_updated(), T1_DrawLabels(), T1_OnDraw(), test_32bit_ddb(), test_bitmap_colors(), test_clipping(), Test_CreateDIBitmap_CBM_CREATDIB(), test_D3DKMTCreateDCFromMemory(), test_dibsections(), test_emf_BitBlt(), test_printer_dc(), Test_Rectangle(), Test_SrcMono1(), ThemeEndBufferedPaint(), TOOLBAR_DrawMasked(), TRACKBAR_Refresh(), UXTHEME_SizedBlt(), VidBitBlt(), VidBufferToScreenBlt(), WinGBitBlt(), WndProc(), and ZoomWnd_OnDraw().

RleBitBlt()

static VOID RleBitBlt ( _In_ ULONG  Left, _In_ ULONG  Top, _In_ ULONG  Width, _In_ ULONG  Height, _In_ PUCHAR  Buffer  )

static

Definition at line 104 of file common.c.

{
    ULONG YDelta;
    ULONG x;
    ULONG RleValue, NewRleValue;
    ULONG Color, Color2;
    ULONG i, j;
    ULONG Code;
 
    PrepareForSetPixel();
 
    /* Set Y height and current X value and start loop */
    YDelta = Top + Height - 1;
    x = Left;
    for (;;)
    {
        /* Get the current value and advance in the buffer */
        RleValue = *Buffer;
        Buffer++;
        if (RleValue)
        {
            /* Check if we've gone past the edge */
            if ((x + RleValue) > (Width + Left))
            {
                /* Fixup the pixel value */
                RleValue = Left - x + Width;
            }
 
            /* Get the new value */
            NewRleValue = *Buffer;
 
            /* Get the two colors */
            Color = NewRleValue >> 4;
            Color2 = NewRleValue & 0xF;
 
            /* Increase buffer position */
            Buffer++;
 
            /* Check if we need to do a fill */
            if (Color == Color2)
            {
                /* Do a fill and continue the loop */
                RleValue += x;
                VidSolidColorFill(x, YDelta, RleValue - 1, YDelta, (UCHAR)Color);
                x = RleValue;
                continue;
            }
 
            /* Check if the pixel value is 1 or below */
            if (RleValue > 1)
            {
                /* Set loop variables */
                for (i = (RleValue - 2) / 2 + 1; i > 0; --i)
                {
                    /* Set the pixels */
                    SetPixel(x, YDelta, (UCHAR)Color);
                    x++;
                    SetPixel(x, YDelta, (UCHAR)Color2);
                    x++;
 
                    /* Decrease pixel value */
                    RleValue -= 2;
                }
            }
 
            /* Check if there is any value at all */
            if (RleValue)
            {
                /* Set the pixel and increase position */
                SetPixel(x, YDelta, (UCHAR)Color);
                x++;
            }
 
            /* Start over */
            continue;
        }
 
        /* Get the current pixel value */
        RleValue = *Buffer;
        Code = RleValue;
        switch (Code)
        {
            /* Case 0 */
            case 0:
            {
                /* Set new x value, decrease distance and restart */
                x = Left;
                YDelta--;
                Buffer++;
                continue;
            }
 
            /* Case 1 */
            case 1:
            {
                /* Done */
                return;
            }
 
            /* Case 2 */
            case 2:
            {
                /* Set new x value, decrease distance and restart */
                Buffer++;
                x += *Buffer;
                Buffer++;
                YDelta -= *Buffer;
                Buffer++;
                continue;
            }
 
            /* Other values */
            default:
            {
                Buffer++;
                break;
            }
        }
 
        /* Check if we've gone past the edge */
        if ((x + RleValue) > (Width + Left))
        {
            /* Set fixed up loop count */
            i = RleValue - Left - Width + x;
 
            /* Fixup pixel value */
            RleValue -= i;
        }
        else
        {
            /* Clear loop count */
            i = 0;
        }
 
        /* Check the value now */
        if (RleValue > 1)
        {
            /* Set loop variables */
            for (j = (RleValue - 2) / 2 + 1; j > 0; --j)
            {
                /* Get the new value */
                NewRleValue = *Buffer;
 
                /* Get the two colors */
                Color = NewRleValue >> 4;
                Color2 = NewRleValue & 0xF;
 
                /* Increase buffer position */
                Buffer++;
 
                /* Set the pixels */
                SetPixel(x, YDelta, (UCHAR)Color);
                x++;
                SetPixel(x, YDelta, (UCHAR)Color2);
                x++;
 
                /* Decrease pixel value */
                RleValue -= 2;
            }
        }
 
        /* Check if there is any value at all */
        if (RleValue)
        {
            /* Set the pixel and increase position */
            Color = *Buffer >> 4;
            Buffer++;
            SetPixel(x, YDelta, (UCHAR)Color);
            x++;
            i--;
        }
 
        /* Check loop count now */
        if ((LONG)i > 0)
        {
            /* Decrease it */
            i--;
 
            /* Set new position */
            Buffer = Buffer + (i / 2) + 1;
        }
 
        /* Check if we need to increase the buffer */
        if ((ULONG_PTR)Buffer & 1) Buffer++;
    }
}

Referenced by VidBitBlt().

VidBitBlt()

VOID NTAPI VidBitBlt	(	_In_ PUCHAR	Buffer,
		_In_ ULONG	Left,
		_In_ ULONG	Top
	)

Definition at line 318 of file common.c.

{
    PBITMAPINFOHEADER BitmapInfoHeader;
    LONG Delta;
    PUCHAR BitmapOffset;
    ULONG PaletteCount;
 
    /* Get the Bitmap Header */
    BitmapInfoHeader = (PBITMAPINFOHEADER)Buffer;
 
    /* Initialize the palette */
    PaletteCount = BitmapInfoHeader->biClrUsed ?
                   BitmapInfoHeader->biClrUsed : BV_MAX_COLORS;
    InitPaletteWithTable((PULONG)(Buffer + BitmapInfoHeader->biSize),
                         PaletteCount);
 
    /* Make sure we can support this bitmap */
    ASSERT((BitmapInfoHeader->biBitCount * BitmapInfoHeader->biPlanes) <= 4);
 
    /*
     * Calculate the delta and align it on 32-bytes, then calculate
     * the actual start of the bitmap data.
     */
    Delta = (BitmapInfoHeader->biBitCount * BitmapInfoHeader->biWidth) + 31;
    Delta >>= 3;
    Delta &= ~3;
    BitmapOffset = Buffer + sizeof(BITMAPINFOHEADER) + PaletteCount * sizeof(ULONG);
 
    /* Check the compression of the bitmap */
    if (BitmapInfoHeader->biCompression == BI_RLE4)
    {
        /* Make sure we have a width and a height */
        if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
        {
            /* We can use RLE Bit Blt */
            RleBitBlt(Left,
                      Top,
                      BitmapInfoHeader->biWidth,
                      BitmapInfoHeader->biHeight,
                      BitmapOffset);
        }
    }
    else
    {
        /* Check if the height is negative */
        if (BitmapInfoHeader->biHeight < 0)
        {
            /* Make it positive in the header */
            BitmapInfoHeader->biHeight *= -1;
        }
        else
        {
            /* Update buffer offset */
            BitmapOffset += ((BitmapInfoHeader->biHeight - 1) * Delta);
            Delta *= -1;
        }
 
        /* Make sure we have a width and a height */
        if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
        {
            /* Do the BitBlt */
            BitBlt(Left,
                   Top,
                   BitmapInfoHeader->biWidth,
                   BitmapInfoHeader->biHeight,
                   BitmapOffset,
                   BitmapInfoHeader->biBitCount,
                   Delta);
        }
    }
}

Referenced by BootLogoFadeIn(), and InbvBitBlt().

VidBufferToScreenBlt()

VOID NTAPI VidBufferToScreenBlt	(	_In_reads_bytes_(Delta *Height) PUCHAR	Buffer,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Width,
		_In_ ULONG	Height,
		_In_ ULONG	Delta
	)

Definition at line 300 of file common.c.

{
    /* Make sure we have a width and height */
    if (!Width || !Height)
        return;
 
    /* Call the helper function */
    BitBlt(Left, Top, Width, Height, Buffer, 4, Delta);
}

Referenced by InbvBufferToScreenBlt(), and InbvRotationThread().

Variable Documentation

VidpDefaultPalette

const RGBQUAD VidpDefaultPalette[BV_MAX_COLORS]

Initial value:

=
{
    RGB(  0,   0,   0), 
    RGB(128,   0,   0), 
    RGB(  0, 128,   0), 
    RGB(128, 128,   0), 
    RGB(  0,   0, 128), 
    RGB(128,   0, 128), 
    RGB(  0, 128, 128), 
    RGB(128, 128, 128), 
    RGB(192, 192, 192), 
    RGB(255,   0,   0), 
    RGB(  0, 255,   0), 
    RGB(255, 255,   0), 
    RGB(  0,   0, 255), 
    RGB(255,   0, 255), 
    RGB(  0, 255, 255), 
    RGB(255, 255, 255), 
}

Definition at line 19 of file common.c.

Referenced by InitPaletteWithTable(), and VidpBuildColor().