vidfb.h File Reference

#include "twidbits.h"

Include dependency graph for vidfb.h:

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

Go to the source code of this file.

Classes
struct	_PIXEL_BITMASK
	Physical format of an RGB pixel, specified with per-component bit-masks. A bit being set defines those used for the given color component, such as Red, Green, Blue, or Reserved. More...

Typedefs
typedef struct _PIXEL_BITMASK	PIXEL_BITMASK
	Physical format of an RGB pixel, specified with per-component bit-masks. A bit being set defines those used for the given color component, such as Red, Green, Blue, or Reserved.
typedef struct _PIXEL_BITMASK *	PPIXEL_BITMASK

Functions
FORCEINLINE ULONG	PixelBitmasksToBpp (_In_ ULONG RedMask, _In_ ULONG GreenMask, _In_ ULONG BlueMask, _In_ ULONG ReservedMask)
	Calculates the number of bits per pixel ("PixelDepth") for the given pixel format, given by the pixel color masks.
BOOLEAN	VidFbInitializeVideo (_In_ ULONG_PTR BaseAddress, _In_ ULONG BufferSize, _In_ UINT32 ScreenWidth, _In_ UINT32 ScreenHeight, _In_ UINT32 PixelsPerScanLine, _In_ UINT32 BitsPerPixel, _In_opt_ PPIXEL_BITMASK PixelMasks)
	Initializes internal framebuffer information based on the given parameters.
VOID	VidFbClearScreenColor (_In_ UINT32 Color, _In_ BOOLEAN FullScreen)
VOID	VidFbOutputChar (_In_ UCHAR Char, _In_ ULONG X, _In_ ULONG Y, _In_ UINT32 FgColor, _In_ UINT32 BgColor)
	Displays a character at a given pixel position with specific foreground and background colors.
VOID	VidFbGetDisplaySize (_Out_ PULONG Width, _Out_ PULONG Height, _Out_ PULONG Depth)
	Returns the width and height in pixels, of the whole visible area of the graphics framebuffer.
ULONG	VidFbGetBufferSize (VOID)
	Returns the size in bytes, of a full graphics pixel buffer rectangle that can fill the whole visible area of the graphics framebuffer.
VOID	VidFbScrollUp (_In_ UINT32 Color, _In_ ULONG Scroll)
VOID	FbConsClearScreen (_In_ UCHAR Attr)
VOID	FbConsOutputChar (_In_ UCHAR Char, _In_ ULONG Column, _In_ ULONG Row, _In_ UINT32 FgColor, _In_ UINT32 BgColor)
	Displays a character at a given position with specific foreground and background colors.
VOID	FbConsPutChar (_In_ UCHAR Char, _In_ UCHAR Attr, _In_ ULONG Column, _In_ ULONG Row)
	Displays a character with specific text attributes at a given position.
VOID	FbConsGetDisplaySize (_Out_ PULONG Width, _Out_ PULONG Height, _Out_ PULONG Depth)
	Returns the width and height in number of CGA characters/attributes, of a full text-mode CGA-style character buffer rectangle that can fill the whole console.
ULONG	FbConsGetBufferSize (VOID)
	Returns the size in bytes, of a full text-mode CGA-style character buffer rectangle that can fill the whole console.
VOID	FbConsCopyOffScreenBufferToVRAM (_In_ PVOID Buffer)
	Copies a full text-mode CGA-style character buffer rectangle to the console.
VOID	FbConsScrollUp (_In_ UCHAR Attr)

Typedef Documentation

PIXEL_BITMASK

typedef struct _PIXEL_BITMASK PIXEL_BITMASK

Physical format of an RGB pixel, specified with per-component bit-masks. A bit being set defines those used for the given color component, such as Red, Green, Blue, or Reserved.

Note

Supports up to 32 bits-per-pixel deep pixels.

PPIXEL_BITMASK

typedef struct _PIXEL_BITMASK * PPIXEL_BITMASK

Function Documentation

FbConsClearScreen()

VOID FbConsClearScreen

(

_In_ UCHAR

Attr

)

Definition at line 377 of file vidfb.c.

{
    UINT32 FgColor, BgColor;
    FbConsAttrToColors(Attr, &FgColor, &BgColor);
    VidFbClearScreenColor(BgColor, FALSE);
}

Referenced by UefiVideoClearScreen(), and XboxVideoClearScreen().

FbConsCopyOffScreenBufferToVRAM()

VOID FbConsCopyOffScreenBufferToVRAM

(

_In_ PVOID

Buffer

)

Copies a full text-mode CGA-style character buffer rectangle to the console.

Definition at line 456 of file vidfb.c.

{
    PUCHAR OffScreenBuffer = (PUCHAR)Buffer;
    ULONG Row, Col;
 
    // ULONG Width, Height, Depth;
    // FbConsGetDisplaySize(&Width, &Height, &Depth);
    ULONG Width = FBCONS_WIDTH, Height = FBCONS_HEIGHT;
 
    for (Row = 0; Row < Height; ++Row)
    {
        for (Col = 0; Col < Width; ++Col)
        {
            FbConsPutChar(OffScreenBuffer[0], OffScreenBuffer[1], Col, Row);
            OffScreenBuffer += VGA_CHAR_SIZE;
        }
    }
}

Referenced by UefiVideoCopyOffScreenBufferToVRAM(), and XboxVideoCopyOffScreenBufferToVRAM().

FbConsGetBufferSize()

ULONG FbConsGetBufferSize

(

VOID

)

Returns the size in bytes, of a full text-mode CGA-style character buffer rectangle that can fill the whole console.

Definition at line 445 of file vidfb.c.

{
    return (FBCONS_HEIGHT * FBCONS_WIDTH * VGA_CHAR_SIZE);
}

Referenced by UefiVideoGetBufferSize(), and XboxVideoGetBufferSize().

FbConsGetDisplaySize()

VOID FbConsGetDisplaySize	(	_Out_ PULONG	Width,
		_Out_ PULONG	Height,
		_Out_ PULONG	Depth
	)

Returns the width and height in number of CGA characters/attributes, of a full text-mode CGA-style character buffer rectangle that can fill the whole console.

Definition at line 426 of file vidfb.c.

{
    // VidFbGetDisplaySize(Width, Height, Depth);
    // *Width  /= CHAR_WIDTH;
    // *Height /= CHAR_HEIGHT;
    *Width  = FBCONS_WIDTH;
    *Height = FBCONS_HEIGHT;
    *Depth  = framebufInfo.BitsPerPixel;
}

Referenced by UefiVideoGetDisplaySize(), and XboxVideoGetDisplaySize().

FbConsOutputChar()

VOID FbConsOutputChar	(	_In_ UCHAR	Char,
		_In_ ULONG	Column,
		_In_ ULONG	Row,
		_In_ UINT32	FgColor,
		_In_ UINT32	BgColor
	)

Displays a character at a given position with specific foreground and background colors.

Definition at line 391 of file vidfb.c.

{
    /* Don't display outside of the screen */
    if ((Column >= FBCONS_WIDTH) || (Row >= FBCONS_HEIGHT))
        return;
    VidFbOutputChar(Char, Column * CHAR_WIDTH, Row * CHAR_HEIGHT, FgColor, BgColor);
}

Referenced by FbConsPutChar().

FbConsPutChar()

VOID FbConsPutChar	(	_In_ UCHAR	Char,
		_In_ UCHAR	Attr,
		_In_ ULONG	Column,
		_In_ ULONG	Row
	)

Displays a character with specific text attributes at a given position.

Definition at line 409 of file vidfb.c.

{
    UINT32 FgColor, BgColor;
    FbConsAttrToColors(Attr, &FgColor, &BgColor);
    FbConsOutputChar(Char, Column, Row, FgColor, BgColor);
}

Referenced by FbConsCopyOffScreenBufferToVRAM(), UefiVideoPutChar(), and XboxVideoPutChar().

FbConsScrollUp()

VOID FbConsScrollUp

(

_In_ UCHAR

Attr

)

Definition at line 477 of file vidfb.c.

{
    UINT32 BgColor, Dummy;
    FbConsAttrToColors(Attr, &Dummy, &BgColor);
    VidFbScrollUp(BgColor, CHAR_HEIGHT);
}

Referenced by UefiConsPutChar(), and XboxConsPutChar().

PixelBitmasksToBpp()

FORCEINLINE ULONG PixelBitmasksToBpp	(	_In_ ULONG	RedMask,
		_In_ ULONG	GreenMask,
		_In_ ULONG	BlueMask,
		_In_ ULONG	ReservedMask
	)

Calculates the number of bits per pixel ("PixelDepth") for the given pixel format, given by the pixel color masks.

Remarks

See UEFI Spec Rev.2.10 Section 12.9 "Graphics Output Protocol": example code "GetPixelElementSize()" function.

Definition at line 41 of file vidfb.h.

{
    ULONG CompoundMask = (RedMask | GreenMask | BlueMask | ReservedMask);
    /* Alternatively, the calculation could be done by finding the highest
     * bit set in the combined pixel color masks, if they are packed together. */
    return CountNumberOfBits(CompoundMask); // FindHighestSetBit(CompoundMask);
}

Referenced by UefiInitializeVideo(), and VidFbInitializeVideo().

VidFbClearScreenColor()

VOID VidFbClearScreenColor	(	_In_ UINT32	Color,
		_In_ BOOLEAN	FullScreen
	)

Definition at line 194 of file vidfb.c.

{
    ULONG Line, Col;
    PUINT32 p;
 
    for (Line = 0; Line < framebufInfo.ScreenHeight - (FullScreen ? 0 : 2 * TOP_BOTTOM_LINES); Line++)
    {
        p = (PUINT32)((PUCHAR)framebufInfo.BaseAddress + (Line + (FullScreen ? 0 : TOP_BOTTOM_LINES)) * framebufInfo.Delta);
        for (Col = 0; Col < framebufInfo.ScreenWidth; Col++)
        {
            *p++ = Color;
        }
    }
}

Referenced by FbConsClearScreen(), XboxVideoInit(), and XboxVideoPrepareForReactOS().

VidFbGetBufferSize()

ULONG VidFbGetBufferSize

(

VOID

)

Returns the size in bytes, of a full graphics pixel buffer rectangle that can fill the whole visible area of the graphics framebuffer.

Definition at line 274 of file vidfb.c.

{
    return ((framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES) *
            framebufInfo.ScreenWidth * framebufInfo.BytesPerPixel);
}

VidFbGetDisplaySize()

VOID VidFbGetDisplaySize	(	_Out_ PULONG	Width,
		_Out_ PULONG	Height,
		_Out_ PULONG	Depth
	)

Returns the width and height in pixels, of the whole visible area of the graphics framebuffer.

Definition at line 258 of file vidfb.c.

{
    *Width  = framebufInfo.ScreenWidth;
    *Height = framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES;
    *Depth  = framebufInfo.BitsPerPixel;
}

VidFbInitializeVideo()

BOOLEAN VidFbInitializeVideo	(	_In_ ULONG_PTR	BaseAddress,
		_In_ ULONG	BufferSize,
		_In_ UINT32	ScreenWidth,
		_In_ UINT32	ScreenHeight,
		_In_ UINT32	PixelsPerScanLine,
		_In_ UINT32	BitsPerPixel,
		_In_opt_ PPIXEL_BITMASK	PixelMasks
	)

Initializes internal framebuffer information based on the given parameters.

Parameters

[in]	BaseAddress	The framebuffer physical base address.
[in]	BufferSize	The framebuffer size, in bytes.
[in]	ScreenWidth
[in]	ScreenHeight	The width and height of the visible framebuffer area, in pixels.
[in]	PixelsPerScanLine	The size in number of pixels of a whole horizontal video memory scanline.
[in]	BitsPerPixel	The number of usable bits (not counting the reserved ones) per pixel.
[in]	PixelMasks	Optional pointer to a PIXEL_BITMASK structure describing the pixel format used by the framebuffer.

Returns

TRUE if initialization is successful; FALSE if not.

Definition at line 97 of file vidfb.c.

{
    PPIXEL_BITMASK BitMasks = &framebufInfo.PixelMasks;
 
    RtlZeroMemory(&framebufInfo, sizeof(framebufInfo));
 
    framebufInfo.BaseAddress  = BaseAddress;
    framebufInfo.BufferSize   = BufferSize;
    framebufInfo.ScreenWidth  = ScreenWidth;
    framebufInfo.ScreenHeight = ScreenHeight;
    framebufInfo.PixelsPerScanLine = PixelsPerScanLine;
    framebufInfo.BitsPerPixel = BitsPerPixel;
 
    framebufInfo.BytesPerPixel = ((BitsPerPixel + 7) & ~7) / 8; // Round up to nearest byte.
    framebufInfo.Delta = (PixelsPerScanLine * framebufInfo.BytesPerPixel + 3) & ~3;
 
    /* We currently only support 32bpp */
    if (BitsPerPixel != 32)
    {
        /* Unsupported BPP */
        ERR("Unsupported %lu bits per pixel format\n", BitsPerPixel);
        return FALSE;
    }
 
    //ASSERT((BitsPerPixel <= 8 && !PixelMasks) || (BitsPerPixel > 8));
    if (BitsPerPixel > 8)
    {
        if (!PixelMasks ||
            (PixelMasks->RedMask   == 0 &&
             PixelMasks->GreenMask == 0 &&
             PixelMasks->BlueMask  == 0 /* &&
             PixelMasks->ReservedMask == 0 */))
        {
            /* Determine pixel mask given color depth and color channel */
            switch (BitsPerPixel)
            {
                case 32:
                case 24: /* 8:8:8 */
                    BitMasks->RedMask   = 0x00FF0000; // 0x00FF0000;
                    BitMasks->GreenMask = 0x0000FF00; // 0x00FF0000 >> 8;
                    BitMasks->BlueMask  = 0x000000FF; // 0x00FF0000 >> 16;
                    BitMasks->ReservedMask = ((1 << (BitsPerPixel - 24)) - 1) << 24;
                    break;
                case 16: /* 5:6:5 */
                    BitMasks->RedMask   = 0xF800; // 0xF800;
                    BitMasks->GreenMask = 0x07E0; // (0xF800 >> 5) | 0x20;
                    BitMasks->BlueMask  = 0x001F; // 0xF800 >> 11;
                    BitMasks->ReservedMask = 0;
                    break;
                case 15: /* 5:5:5 */
                    BitMasks->RedMask   = 0x7C00; // 0x7C00;
                    BitMasks->GreenMask = 0x03E0; // 0x7C00 >> 5;
                    BitMasks->BlueMask  = 0x001F; // 0x7C00 >> 10;
                    BitMasks->ReservedMask = 0x8000;
                    break;
                default:
                    /* Unsupported BPP */
                    UNIMPLEMENTED;
                    RtlZeroMemory(BitMasks, sizeof(*BitMasks));
            }
        }
        else
        {
            /* Copy the pixel masks */
            RtlCopyMemory(BitMasks, PixelMasks, sizeof(*BitMasks));
        }
    }
    else
    {
        /* Palettized modes don't use masks */
        RtlZeroMemory(BitMasks, sizeof(*BitMasks));
    }
 
#if DBG
    VidFbPrintFramebufferInfo();
    {
    ULONG BppFromMasks =
        PixelBitmasksToBpp(BitMasks->RedMask,
                           BitMasks->GreenMask,
                           BitMasks->BlueMask,
                           BitMasks->ReservedMask);
    TRACE("BitsPerPixel = %lu , BppFromMasks = %lu\n", BitsPerPixel, BppFromMasks);
    //ASSERT(BitsPerPixel == BppFromMasks);
    }
#endif
 
    return TRUE;
}

Referenced by UefiInitializeVideo(), and XboxVideoInit().

VidFbOutputChar()

VOID VidFbOutputChar	(	_In_ UCHAR	Char,
		_In_ ULONG	X,
		_In_ ULONG	Y,
		_In_ UINT32	FgColor,
		_In_ UINT32	BgColor
	)

Displays a character at a given pixel position with specific foreground and background colors.

Definition at line 217 of file vidfb.c.

{
    const UCHAR* FontPtr;
    PUINT32 Pixel;
    UCHAR Mask;
    ULONG Line, Col;
 
    /* Don't display outside of the screen, nor partial characters */
    if ((X + CHAR_WIDTH >= framebufInfo.ScreenWidth) ||
        (Y + CHAR_HEIGHT >= (framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES)))
    {
        return;
    }
 
    FontPtr = BitmapFont8x16 + Char * CHAR_HEIGHT;
    Pixel = (PUINT32)((PUCHAR)framebufInfo.BaseAddress +
            (Y + TOP_BOTTOM_LINES) * framebufInfo.Delta + X * sizeof(UINT32));
 
    for (Line = 0; Line < CHAR_HEIGHT; Line++)
    {
        Mask = 0x80;
        for (Col = 0; Col < CHAR_WIDTH; Col++)
        {
            Pixel[Col] = (0 != (FontPtr[Line] & Mask) ? FgColor : BgColor);
            Mask = Mask >> 1;
        }
        Pixel = (PUINT32)((PUCHAR)Pixel + framebufInfo.Delta);
    }
}

Referenced by FbConsOutputChar().

VidFbScrollUp()

VOID VidFbScrollUp	(	_In_ UINT32	Color,
		_In_ ULONG	Scroll
	)

Definition at line 281 of file vidfb.c.

{
    PUINT32 Dst = (PUINT32)((PUCHAR)framebufInfo.BaseAddress + TOP_BOTTOM_LINES * framebufInfo.Delta);
    PUINT32 Src = (PUINT32)((PUCHAR)framebufInfo.BaseAddress + (TOP_BOTTOM_LINES + Scroll) * framebufInfo.Delta);
    ULONG PixelCount = framebufInfo.ScreenWidth * ((framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES) - Scroll);
 
    while (PixelCount--)
        *Dst++ = *Src++;
 
    for (PixelCount = 0; PixelCount < framebufInfo.ScreenWidth * Scroll; PixelCount++)
        *Dst++ = Color;
}

Referenced by FbConsScrollUp().