#include <freeldr.h>
#include "vidfb.h"
#include "vgafont.h"
#include <debug.h>

Include dependency graph for vidfb.c:

Classes
struct	_FRAMEBUFFER_INFO

Macros
#define	TOP_BOTTOM_LINES 0

#define	VGA_CHAR_SIZE 2

#define	FBCONS_WIDTH (framebufInfo.ScreenWidth / CHAR_WIDTH)

#define	FBCONS_HEIGHT ((framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES) / CHAR_HEIGHT)

Typedefs
typedef struct _FRAMEBUFFER_INFO	FRAMEBUFFER_INFO

typedef struct _FRAMEBUFFER_INFO *	PFRAMEBUFFER_INFO

Functions
	DBG_DEFAULT_CHANNEL (UI)

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)

static UINT32	FbConsAttrToSingleColor (_In_ UCHAR Attr)

static VOID	FbConsAttrToColors (_In_ UCHAR Attr, _Out_ PUINT32 FgColor, _Out_ PUINT32 BgColor)
	Maps a text-mode CGA-style character attribute to separate foreground and background ARGB colors.

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)

Variables
FRAMEBUFFER_INFO	framebufInfo

Macro Definition Documentation

◆ FBCONS_HEIGHT

#define FBCONS_HEIGHT ((framebufInfo.ScreenHeight - 2 * TOP_BOTTOM_LINES) / CHAR_HEIGHT)

Definition at line 345 of file vidfb.c.

◆ FBCONS_WIDTH

#define FBCONS_WIDTH (framebufInfo.ScreenWidth / CHAR_WIDTH)

Definition at line 344 of file vidfb.c.

◆ TOP_BOTTOM_LINES

#define TOP_BOTTOM_LINES 0

Definition at line 17 of file vidfb.c.

◆ VGA_CHAR_SIZE

#define VGA_CHAR_SIZE 2

Definition at line 342 of file vidfb.c.

Typedef Documentation

◆ FRAMEBUFFER_INFO

typedef struct _FRAMEBUFFER_INFO FRAMEBUFFER_INFO

◆ PFRAMEBUFFER_INFO

typedef struct _FRAMEBUFFER_INFO * PFRAMEBUFFER_INFO

Function Documentation

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UI )

◆ FbConsAttrToColors()

static VOID FbConsAttrToColors	(	_In_ UCHAR	Attr,
		_Out_ PUINT32	FgColor,
		_Out_ PUINT32	BgColor
	)

static

Maps a text-mode CGA-style character attribute to separate foreground and background ARGB colors.

Definition at line 367 of file vidfb.c.

{
    *FgColor = FbConsAttrToSingleColor(Attr & 0x0F);
    *BgColor = FbConsAttrToSingleColor((Attr >> 4) & 0x0F);
}

Referenced by FbConsClearScreen(), FbConsPutChar(), and FbConsScrollUp().

◆ FbConsAttrToSingleColor()

static UINT32 FbConsAttrToSingleColor ( _In_ UCHAR Attr )

inlinestatic

Definition at line 349 of file vidfb.c.

{
    UCHAR Intensity;
    Intensity = (0 == (Attr & 0x08) ? 127 : 255);
 
    return 0xff000000 |
           (0 == (Attr & 0x04) ? 0 : (Intensity << 16)) |
           (0 == (Attr & 0x02) ? 0 : (Intensity << 8)) |
           (0 == (Attr & 0x01) ? 0 : Intensity);
}

Referenced by FbConsAttrToColors().

◆ 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().

◆ 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().

Variable Documentation

◆ framebufInfo

FRAMEBUFFER_INFO framebufInfo

Definition at line 43 of file vidfb.c.

Referenced by FbConsGetDisplaySize(), VidFbClearScreenColor(), VidFbGetBufferSize(), VidFbGetDisplaySize(), VidFbInitializeVideo(), VidFbOutputChar(), and VidFbScrollUp().

Classes

Macros

Typedefs

Functions

Variables