bootvid.h File Reference

#include "display.h"

Include dependency graph for bootvid.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BOOLEAN NTAPI	VidInitialize (_In_ BOOLEAN SetMode)
VOID NTAPI	VidResetDisplay (_In_ BOOLEAN HalReset)
ULONG NTAPI	VidSetTextColor (_In_ ULONG Color)
VOID NTAPI	VidDisplayStringXY (_In_z_ PUCHAR String, _In_ ULONG Left, _In_ ULONG Top, _In_ BOOLEAN Transparent)
VOID NTAPI	VidSetScrollRegion (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ ULONG Bottom)
VOID NTAPI	VidCleanUp (VOID)
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	VidDisplayString (_In_z_ PUCHAR String)
VOID NTAPI	VidBitBlt (_In_ PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top)
VOID NTAPI	VidScreenToBufferBlt (_Out_writes_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_ ULONG Delta)
VOID NTAPI	VidSolidColorFill (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ ULONG Bottom, _In_ UCHAR Color)

Function Documentation

VidBitBlt()

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

Definition at line 470 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 452 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().

VidCleanUp()

VOID NTAPI VidCleanUp

(

VOID

)

Definition at line 246 of file bootvid.c.

{
    UNIMPLEMENTED;
    while (TRUE);
}

Referenced by InbvEnableBootDriver(), and InbvNotifyDisplayOwnershipLost().

VidDisplayString()

VOID NTAPI VidDisplayString

(

_In_z_ PUCHAR

String

)

Definition at line 374 of file common.c.

{
    /* Start looping the string */
    for (; *String; ++String)
    {
        /* Treat new-line separately */
        if (*String == '\n')
        {
            /* Modify Y position */
            VidpCurrentY += BOOTCHAR_HEIGHT + 1;
            if (VidpCurrentY + BOOTCHAR_HEIGHT > VidpScrollRegion[3])
            {
                /* Scroll the view and clear the current row */
                DoScroll(BOOTCHAR_HEIGHT + 1);
                VidpCurrentY -= BOOTCHAR_HEIGHT + 1;
                PreserveRow(VidpCurrentY, BOOTCHAR_HEIGHT + 1, TRUE);
            }
            else
            {
                /* Preserve the current row */
                PreserveRow(VidpCurrentY, BOOTCHAR_HEIGHT + 1, FALSE);
            }
 
            /* Update current X */
            VidpCurrentX = VidpScrollRegion[0];
 
            /* No need to clear this row */
            ClearRow = FALSE;
        }
        else if (*String == '\r')
        {
            /* Update current X */
            VidpCurrentX = VidpScrollRegion[0];
 
            /* If a new-line does not follow we will clear the current row */
            if (String[1] != '\n') ClearRow = TRUE;
        }
        else
        {
            /* Clear the current row if we had a return-carriage without a new-line */
            if (ClearRow)
            {
                PreserveRow(VidpCurrentY, BOOTCHAR_HEIGHT + 1, TRUE);
                ClearRow = FALSE;
            }
 
            /* Display this character */
            DisplayCharacter(*String, VidpCurrentX, VidpCurrentY, VidpTextColor, BV_COLOR_NONE);
            VidpCurrentX += BOOTCHAR_WIDTH;
 
            /* Check if we should scroll */
            if (VidpCurrentX + BOOTCHAR_WIDTH - 1 > VidpScrollRegion[2])
            {
                /* Update Y position and check if we should scroll it */
                VidpCurrentY += BOOTCHAR_HEIGHT + 1;
                if (VidpCurrentY + BOOTCHAR_HEIGHT > VidpScrollRegion[3])
                {
                    /* Scroll the view and clear the current row */
                    DoScroll(BOOTCHAR_HEIGHT + 1);
                    VidpCurrentY -= BOOTCHAR_HEIGHT + 1;
                    PreserveRow(VidpCurrentY, BOOTCHAR_HEIGHT + 1, TRUE);
                }
                else
                {
                    /* Preserve the current row */
                    PreserveRow(VidpCurrentY, BOOTCHAR_HEIGHT + 1, FALSE);
                }
 
                /* Update current X */
                VidpCurrentX = VidpScrollRegion[0];
            }
        }
    }
}

Referenced by InbvDisplayString().

VidDisplayStringXY()

VOID NTAPI VidDisplayStringXY	(	_In_z_ PUCHAR	String,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ BOOLEAN	Transparent
	)

Definition at line 324 of file common.c.

{
    ULONG BackColor;
 
    /*
     * If the caller wanted transparent, then send the special value (16),
     * else use our default and call the helper routine.
     */
    BackColor = Transparent ? BV_COLOR_NONE : BV_COLOR_LIGHT_CYAN;
 
    /* Loop every character and adjust the position */
    for (; *String; ++String, Left += BOOTCHAR_WIDTH)
    {
        /* Display a character */
        DisplayCharacter(*String, Left, Top, BV_COLOR_LIGHT_BLUE, BackColor);
    }
}

VidInitialize()

BOOLEAN NTAPI VidInitialize

(

_In_ BOOLEAN

SetMode

)

Definition at line 184 of file bootvid.c.

{
    DPRINT1("bv-arm v0.1\n");
 
    //
    // Allocate framebuffer
    // 600kb works out to 640x480@16bpp
    //
    VgaPhysical.QuadPart = -1;
    VgaArmBase = MmAllocateContiguousMemory(600 * 1024, VgaPhysical);
    if (!VgaArmBase) return FALSE;
 
    //
    // Get physical address
    //
    VgaPhysical = MmGetPhysicalAddress(VgaArmBase);
    if (!VgaPhysical.QuadPart) return FALSE;
    DPRINT1("[BV-ARM] Frame Buffer @ 0x%p 0p%p\n", VgaArmBase, VgaPhysical.LowPart);
 
    //
    // Setup the display
    //
    VidpInitializeDisplay();
 
    //
    // We are done!
    //
    return TRUE;
}

Referenced by InbvDriverInitialize().

VidResetDisplay()

VOID NTAPI VidResetDisplay

(

_In_ BOOLEAN

HalReset

)

Definition at line 220 of file bootvid.c.

{
    //
    // Clear the current position
    //
    VidpCurrentX = 0;
    VidpCurrentY = 0;
 
    //
    // Re-initialize the VGA Display
    //
    VidpInitializeDisplay();
 
    //
    // Re-initialize the palette and fill the screen black
    //
    InitializePalette();
    VidSolidColorFill(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1, BV_COLOR_BLACK);
}

Referenced by InbvResetDisplay(), and VidInitialize().

VidScreenToBufferBlt()

VOID NTAPI VidScreenToBufferBlt	(	_Out_writes_bytes_(Delta *Height) PUCHAR	Buffer,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Width,
		_In_ ULONG	Height,
		_In_ ULONG	Delta
	)

Definition at line 257 of file bootvid.c.

{
    UNIMPLEMENTED;
    while (TRUE);
}

Referenced by InbvScreenToBufferBlt().

VidSetScrollRegion()

VOID NTAPI VidSetScrollRegion	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ ULONG	Bottom
	)

Definition at line 348 of file common.c.

{
    /* Assert alignment */
    ASSERT((Left % BOOTCHAR_WIDTH) == 0);
    ASSERT((Right % BOOTCHAR_WIDTH) == BOOTCHAR_WIDTH - 1);
 
    /* Set Scroll Region */
    VidpScrollRegion[0] = Left;
    VidpScrollRegion[1] = Top;
    VidpScrollRegion[2] = Right;
    VidpScrollRegion[3] = Bottom;
 
    /* Set current X and Y */
    VidpCurrentX = Left;
    VidpCurrentY = Top;
}

Referenced by InbvSetScrollRegion().

VidSetTextColor()

ULONG NTAPI VidSetTextColor

(

_In_ ULONG

Color

)

Definition at line 311 of file common.c.

{
    ULONG OldColor;
 
    /* Save the old color and set the new one */
    OldColor = VidpTextColor;
    VidpTextColor = Color;
    return OldColor;
}

Referenced by InbvSetTextColor().

VidSolidColorFill()

VOID NTAPI VidSolidColorFill	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ ULONG	Bottom,
		_In_ UCHAR	Color
	)

Definition at line 274 of file bootvid.c.

{
    int y, x;
 
    //
    // Loop along the Y-axis
    //
    for (y = Top; y <= Bottom; y++)
    {
        //
        // Loop along the X-axis
        //
        for (x = Left; x <= Right; x++)
        {
            //
            // Draw the pixel
            //
            SetPixel(x, y, Color);
        }
    }
}

Referenced by BootAnimTickProgressBar(), FinalizeBootLogo(), InbvRotationThread(), InbvSolidColorFill(), RleBitBlt(), VidCleanUp(), and VidResetDisplay().