diff options
Diffstat (limited to 'OptionRomPkg')
| -rw-r--r-- | OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.c | 753 | ||||
| -rw-r--r-- | OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.inf | 34 | ||||
| -rw-r--r-- | OptionRomPkg/OptionRomPkg.dsc | 2 |
3 files changed, 789 insertions, 0 deletions
diff --git a/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.c b/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.c new file mode 100644 index 0000000000..dd54b0799b --- /dev/null +++ b/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.c @@ -0,0 +1,753 @@ +/** @file
+ FrameBufferBltLib - Library to perform blt operations on a frame buffer.
+
+ Copyright (c) 2007 - 2011, Intel Corporation
+ All rights reserved. This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "PiDxe.h"
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BltLib.h>
+#include <Library/DebugLib.h>
+
+#if 0
+#define VDEBUG DEBUG
+#else
+#define VDEBUG(x)
+#endif
+
+#define MAX_LINE_BUFFER_SIZE (SIZE_4KB * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))
+
+UINTN mBltLibColorDepth;
+UINTN mBltLibWidthInBytes;
+UINTN mBltLibBytesPerPixel;
+UINTN mBltLibWidthInPixels;
+UINTN mBltLibHeight;
+UINT8 mBltLibLineBuffer[MAX_LINE_BUFFER_SIZE];
+UINT8 *mBltLibFrameBuffer;
+EFI_GRAPHICS_PIXEL_FORMAT mPixelFormat;
+EFI_PIXEL_BITMASK mPixelBitMasks;
+INTN mPixelShl[4]; // R-G-B-Rsvd
+INTN mPixelShr[4]; // R-G-B-Rsvd
+
+
+VOID
+ConfigurePixelBitMaskFormat (
+ IN EFI_PIXEL_BITMASK *BitMask
+ )
+{
+ UINTN Loop;
+ UINT32 *Masks;
+ UINT32 MergedMasks;
+
+ MergedMasks = 0;
+ Masks = (UINT32*) BitMask;
+ for (Loop = 0; Loop < 3; Loop++) {
+ ASSERT ((Loop == 3) || (Masks[Loop] != 0));
+ ASSERT ((MergedMasks & Masks[Loop]) == 0);
+ mPixelShl[Loop] = HighBitSet32 (Masks[Loop]) - 23 + (Loop * 8);
+ if (mPixelShl[Loop] < 0) {
+ mPixelShr[Loop] = -mPixelShl[Loop];
+ mPixelShl[Loop] = 0;
+ } else {
+ mPixelShr[Loop] = 0;
+ }
+ MergedMasks = (UINT32) (MergedMasks | Masks[Loop]);
+ DEBUG ((EFI_D_INFO, "%d: shl:%d shr:%d mask:%x\n", Loop, mPixelShl[Loop], mPixelShr[Loop], Masks[Loop]));
+ }
+ MergedMasks = (UINT32) (MergedMasks | Masks[3]);
+
+ mBltLibBytesPerPixel = HighBitSet32 (MergedMasks);
+ ASSERT (mBltLibBytesPerPixel >= 0);
+ mBltLibBytesPerPixel = (mBltLibBytesPerPixel + 7) / 8;
+
+ DEBUG ((EFI_D_INFO, "Bytes per pixel: %d\n", mBltLibBytesPerPixel));
+
+ CopyMem (&mPixelBitMasks, BitMask, sizeof (*BitMask));
+}
+
+
+/**
+ Configure the FrameBufferLib instance
+
+ @param[in] FrameBuffer Pointer to the start of the frame buffer
+ @param[in] FrameBufferInfo Describes the frame buffer characteristics
+
+ @retval EFI_INVALID_PARAMETER - Invalid parameter
+ @retval EFI_UNSUPPORTED - The BltLib does not support this configuration
+ @retval EFI_SUCCESS - Blt operation success
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibConfigure (
+ IN VOID *FrameBuffer,
+ IN EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *FrameBufferInfo
+ )
+{
+ STATIC EFI_PIXEL_BITMASK RgbPixelMasks =
+ { 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
+ STATIC EFI_PIXEL_BITMASK BgrPixelMasks =
+ { 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
+
+ switch (FrameBufferInfo->PixelFormat) {
+ case PixelRedGreenBlueReserved8BitPerColor:
+ ConfigurePixelBitMaskFormat (&RgbPixelMasks);
+ break;
+ case PixelBlueGreenRedReserved8BitPerColor:
+ ConfigurePixelBitMaskFormat (&BgrPixelMasks);
+ break;
+ case PixelBitMask:
+ ConfigurePixelBitMaskFormat (&(FrameBufferInfo->PixelInformation));
+ break;
+ case PixelBltOnly:
+ ASSERT (FrameBufferInfo->PixelFormat != PixelBltOnly);
+ return EFI_UNSUPPORTED;
+ default:
+ ASSERT (FALSE);
+ return EFI_INVALID_PARAMETER;
+ }
+ mPixelFormat = FrameBufferInfo->PixelFormat;
+
+ mBltLibFrameBuffer = (UINT8*) FrameBuffer;
+ mBltLibWidthInPixels = (UINTN) FrameBufferInfo->HorizontalResolution;
+ mBltLibHeight = (UINTN) FrameBufferInfo->VerticalResolution;
+ mBltLibWidthInBytes = mBltLibWidthInPixels * mBltLibBytesPerPixel;
+
+ ASSERT (mBltLibWidthInBytes < sizeof (mBltLibLineBuffer));
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt operation.
+
+ @param[in,out] BltBuffer - The data to transfer to screen
+ @param[in] BltOperation - The operation to perform
+ @param[in] SourceX - The X coordinate of the source for BltOperation
+ @param[in] SourceY - The Y coordinate of the source for BltOperation
+ @param[in] DestinationX - The X coordinate of the destination for BltOperation
+ @param[in] DestinationY - The Y coordinate of the destination for BltOperation
+ @param[in] Width - The width of a rectangle in the blt rectangle in pixels
+ @param[in] Height - The height of a rectangle in the blt rectangle in pixels
+ @param[in] Delta - Not used for EfiBltVideoFill and EfiBltVideoToVideo operation.
+ If a Delta of 0 is used, the entire BltBuffer will be operated on.
+ If a subrectangle of the BltBuffer is used, then Delta represents
+ the number of bytes in a row of the BltBuffer.
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - Blt operation success
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibGopBlt (
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
+ IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN Delta
+ )
+{
+ switch (BltOperation) {
+ case EfiBltVideoToBltBuffer:
+ return BltLibVideoToBltBufferEx (
+ BltBuffer,
+ SourceX,
+ SourceY,
+ DestinationX,
+ DestinationY,
+ Width,
+ Height,
+ Delta
+ );
+
+ case EfiBltVideoToVideo:
+ return BltLibVideoToVideo (
+ SourceX,
+ SourceY,
+ DestinationX,
+ DestinationY,
+ Width,
+ Height
+ );
+
+ case EfiBltVideoFill:
+ return BltLibVideoFill (
+ BltBuffer,
+ DestinationX,
+ DestinationY,
+ Width,
+ Height
+ );
+
+ case EfiBltBufferToVideo:
+ return BltLibBufferToVideoEx (
+ BltBuffer,
+ SourceX,
+ SourceY,
+ DestinationX,
+ DestinationY,
+ Width,
+ Height,
+ Delta
+ );
+ default:
+ return EFI_INVALID_PARAMETER;
+ }
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Video Fill.
+
+ @param[in] Color Color to fill the region with
+ @param[in] DestinationX X location to start fill operation
+ @param[in] DestinationY Y location to start fill operation
+ @param[in] Width Width (in pixels) to fill
+ @param[in] Height Height to fill
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibVideoFill (
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Color,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height
+ )
+{
+ UINTN DstY;
+ VOID *BltMemSrc;
+ VOID *BltMemDst;
+ UINTN X;
+ UINT8 Uint8;
+ UINT32 Uint32;
+ UINT64 WideFill;
+ BOOLEAN UseWideFill;
+ BOOLEAN LineBufferReady;
+ UINTN Offset;
+ UINTN WidthInBytes;
+ UINTN SizeInBytes;
+
+ //
+ // BltBuffer to Video: Source is BltBuffer, destination is Video
+ //
+ if (DestinationY + Height > mBltLibHeight) {
+ DEBUG ((EFI_D_INFO, "VideoFill: Past screen (Y)\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (DestinationX + Width > mBltLibWidthInPixels) {
+ DEBUG ((EFI_D_INFO, "VideoFill: Past screen (X)\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (Width == 0 || Height == 0) {
+ DEBUG ((EFI_D_INFO, "VideoFill: Width or Height is 0\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ WidthInBytes = Width * mBltLibBytesPerPixel;
+
+ Uint32 = *(UINT32*) Color;
+ WideFill =
+ (UINT32) (
+ (((Uint32 << mPixelShl[0]) >> mPixelShr[0]) & mPixelBitMasks.RedMask) |
+ (((Uint32 << mPixelShl[1]) >> mPixelShr[1]) & mPixelBitMasks.GreenMask) |
+ (((Uint32 << mPixelShl[2]) >> mPixelShr[2]) & mPixelBitMasks.BlueMask)
+ );
+ VDEBUG ((EFI_D_INFO, "VideoFill: color=0x%x, wide-fill=0x%x\n", Uint32, WideFill));
+
+ //
+ // If the size of the pixel data evenly divides the sizeof
+ // WideFill, then a wide fill operation can be used
+ //
+ UseWideFill = TRUE;
+ if ((sizeof (WideFill) % mBltLibBytesPerPixel) == 0) {
+ for (X = mBltLibBytesPerPixel; X < sizeof (WideFill); X++) {
+ ((UINT8*)&WideFill)[X] = ((UINT8*)&WideFill)[X % mBltLibBytesPerPixel];
+ }
+ } else {
+ //
+ // If all the bytes in the pixel are the same value, then use
+ // a wide fill operation.
+ //
+ for (
+ X = 1, Uint8 = ((UINT8*)&WideFill)[0];
+ X < mBltLibBytesPerPixel;
+ X++) {
+ if (Uint8 != ((UINT8*)&WideFill)[X]) {
+ UseWideFill = FALSE;
+ break;
+ }
+ }
+ if (UseWideFill) {
+ SetMem ((VOID*) &WideFill, sizeof (WideFill), Uint8);
+ }
+ }
+
+ if (UseWideFill && (DestinationX == 0) && (Width == mBltLibWidthInPixels)) {
+ VDEBUG ((EFI_D_INFO, "VideoFill (wide, one-shot)\n"));
+ Offset = DestinationY * mBltLibWidthInPixels;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemDst = (VOID*) (mBltLibFrameBuffer + Offset);
+ SizeInBytes = WidthInBytes * Height;
+ if (SizeInBytes >= 8) {
+ SetMem32 (BltMemDst, SizeInBytes & ~3, (UINT32) WideFill);
+ SizeInBytes = SizeInBytes & 3;
+ }
+ if (SizeInBytes > 0) {
+ SetMem (BltMemDst, SizeInBytes, (UINT8)(UINTN) WideFill);
+ }
+ } else {
+ LineBufferReady = FALSE;
+ for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
+ Offset = (DstY * mBltLibWidthInPixels) + DestinationX;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemDst = (VOID*) (mBltLibFrameBuffer + Offset);
+
+ if (UseWideFill && (((UINTN) BltMemDst & 7) == 0)) {
+ VDEBUG ((EFI_D_INFO, "VideoFill (wide)\n"));
+ SizeInBytes = WidthInBytes;
+ if (SizeInBytes >= 8) {
+ SetMem64 (BltMemDst, SizeInBytes & ~7, WideFill);
+ SizeInBytes = SizeInBytes & 7;
+ }
+ if (SizeInBytes > 0) {
+ CopyMem (BltMemDst, (VOID*) &WideFill, SizeInBytes);
+ }
+ } else {
+ VDEBUG ((EFI_D_INFO, "VideoFill (not wide)\n"));
+ if (!LineBufferReady) {
+ CopyMem (mBltLibLineBuffer, &WideFill, mBltLibBytesPerPixel);
+ for (X = 1; X < Width; ) {
+ CopyMem(
+ (mBltLibLineBuffer + (X * mBltLibBytesPerPixel)),
+ mBltLibLineBuffer,
+ MIN (X, Width - X) * mBltLibBytesPerPixel
+ );
+ X = X + MIN (X, Width - X);
+ }
+ BltMemSrc = (VOID *) mBltLibLineBuffer;
+ LineBufferReady = TRUE;
+ }
+ CopyMem (BltMemDst, mBltLibLineBuffer, WidthInBytes);
+ }
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Video to Buffer operation.
+
+ @param[out] BltBuffer Output buffer for pixel color data
+ @param[in] SourceX X location within video
+ @param[in] SourceY Y location within video
+ @param[in] Width Width (in pixels)
+ @param[in] Height Height
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibVideoToBltBuffer (
+ OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN Width,
+ IN UINTN Height
+ )
+{
+ return BltLibVideoToBltBufferEx (
+ BltBuffer,
+ SourceX,
+ SourceY,
+ 0,
+ 0,
+ Width,
+ Height,
+ 0
+ );
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Video to Buffer operation
+ with extended parameters.
+
+ @param[out] BltBuffer Output buffer for pixel color data
+ @param[in] SourceX X location within video
+ @param[in] SourceY Y location within video
+ @param[in] DestinationX X location within BltBuffer
+ @param[in] DestinationY Y location within BltBuffer
+ @param[in] Width Width (in pixels)
+ @param[in] Height Height
+ @param[in] Delta Number of bytes in a row of BltBuffer
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibVideoToBltBufferEx (
+ OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN Delta
+ )
+{
+ UINTN DstY;
+ UINTN SrcY;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
+ VOID *BltMemSrc;
+ VOID *BltMemDst;
+ UINTN X;
+ UINT32 Uint32;
+ UINTN Offset;
+ UINTN WidthInBytes;
+
+ //
+ // Video to BltBuffer: Source is Video, destination is BltBuffer
+ //
+ if (SourceY + Height > mBltLibHeight) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (SourceX + Width > mBltLibWidthInPixels) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (Width == 0 || Height == 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ //
+ // If Delta is zero, then the entire BltBuffer is being used, so Delta
+ // is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size,
+ // the number of bytes in each row can be computed.
+ //
+ if (Delta == 0) {
+ Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
+ }
+
+ WidthInBytes = Width * mBltLibBytesPerPixel;
+
+ //
+ // Video to BltBuffer: Source is Video, destination is BltBuffer
+ //
+ for (SrcY = SourceY, DstY = DestinationY; DstY < (Height + DestinationY); SrcY++, DstY++) {
+
+ Offset = (SrcY * mBltLibWidthInPixels) + SourceX;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemSrc = (VOID *) (mBltLibFrameBuffer + Offset);
+
+ if (mPixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
+ BltMemDst =
+ (VOID *) (
+ (UINT8 *) BltBuffer +
+ (DstY * Delta) +
+ (DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))
+ );
+ } else {
+ BltMemDst = (VOID *) mBltLibLineBuffer;
+ }
+
+ CopyMem (BltMemDst, BltMemSrc, WidthInBytes);
+
+ if (mPixelFormat != PixelBlueGreenRedReserved8BitPerColor) {
+ for (X = 0; X < Width; X++) {
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) ((UINT8 *) BltBuffer + (DstY * Delta) + (DestinationX + X) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ Uint32 = *(UINT32*) (mBltLibLineBuffer + (X * mBltLibBytesPerPixel));
+ *(UINT32*) Blt =
+ (UINT32) (
+ (((Uint32 & mPixelBitMasks.RedMask) >> mPixelShl[0]) << mPixelShr[0]) |
+ (((Uint32 & mPixelBitMasks.GreenMask) >> mPixelShl[1]) << mPixelShr[1]) |
+ (((Uint32 & mPixelBitMasks.BlueMask) >> mPixelShl[2]) << mPixelShr[2])
+ );
+ }
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Buffer to Video operation.
+
+ @param[in] BltBuffer Output buffer for pixel color data
+ @param[in] DestinationX X location within video
+ @param[in] DestinationY Y location within video
+ @param[in] Width Width (in pixels)
+ @param[in] Height Height
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibBufferToVideo (
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height
+ )
+{
+ return BltLibBufferToVideoEx (
+ BltBuffer,
+ 0,
+ 0,
+ DestinationX,
+ DestinationY,
+ Width,
+ Height,
+ 0
+ );
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Buffer to Video operation
+ with extended parameters.
+
+ @param[in] BltBuffer Output buffer for pixel color data
+ @param[in] SourceX X location within BltBuffer
+ @param[in] SourceY Y location within BltBuffer
+ @param[in] DestinationX X location within video
+ @param[in] DestinationY Y location within video
+ @param[in] Width Width (in pixels)
+ @param[in] Height Height
+ @param[in] Delta Number of bytes in a row of BltBuffer
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibBufferToVideoEx (
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN Delta
+ )
+{
+ UINTN DstY;
+ UINTN SrcY;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
+ VOID *BltMemSrc;
+ VOID *BltMemDst;
+ UINTN X;
+ UINT32 Uint32;
+ UINTN Offset;
+ UINTN WidthInBytes;
+
+ //
+ // BltBuffer to Video: Source is BltBuffer, destination is Video
+ //
+ if (DestinationY + Height > mBltLibHeight) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (DestinationX + Width > mBltLibWidthInPixels) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (Width == 0 || Height == 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ //
+ // If Delta is zero, then the entire BltBuffer is being used, so Delta
+ // is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size,
+ // the number of bytes in each row can be computed.
+ //
+ if (Delta == 0) {
+ Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
+ }
+
+ WidthInBytes = Width * mBltLibBytesPerPixel;
+
+ for (SrcY = SourceY, DstY = DestinationY; SrcY < (Height + SourceY); SrcY++, DstY++) {
+
+ Offset = (DstY * mBltLibWidthInPixels) + DestinationX;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemDst = (VOID*) (mBltLibFrameBuffer + Offset);
+
+ if (mPixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
+ BltMemSrc = (VOID *) (UINT8 *) BltBuffer + (SrcY * Delta);
+ } else {
+ for (X = 0; X < Width; X++) {
+ Blt =
+ (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) (
+ (UINT8 *) BltBuffer +
+ (SrcY * Delta) +
+ ((SourceX + X) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))
+ );
+ Uint32 = *(UINT32*) Blt;
+ *(UINT32*) (mBltLibLineBuffer + (X * mBltLibBytesPerPixel)) =
+ (UINT32) (
+ (((Uint32 << mPixelShl[0]) >> mPixelShr[0]) & mPixelBitMasks.RedMask) |
+ (((Uint32 << mPixelShl[1]) >> mPixelShr[1]) & mPixelBitMasks.GreenMask) |
+ (((Uint32 << mPixelShl[2]) >> mPixelShr[2]) & mPixelBitMasks.BlueMask)
+ );
+ }
+ BltMemSrc = (VOID *) mBltLibLineBuffer;
+ }
+
+ CopyMem (BltMemDst, BltMemSrc, WidthInBytes);
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Performs a UEFI Graphics Output Protocol Blt Video to Video operation
+
+ @param[in] SourceX X location within video
+ @param[in] SourceY Y location within video
+ @param[in] DestinationX X location within video
+ @param[in] DestinationY Y location within video
+ @param[in] Width Width (in pixels)
+ @param[in] Height Height
+
+ @retval EFI_DEVICE_ERROR - A hardware error occured
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibVideoToVideo (
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height
+ )
+{
+ VOID *BltMemSrc;
+ VOID *BltMemDst;
+ UINTN Offset;
+ UINTN WidthInBytes;
+ INTN LineStride;
+
+ //
+ // Video to Video: Source is Video, destination is Video
+ //
+ if (SourceY + Height > mBltLibHeight) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (SourceX + Width > mBltLibWidthInPixels) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (DestinationY + Height > mBltLibHeight) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (DestinationX + Width > mBltLibWidthInPixels) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (Width == 0 || Height == 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ WidthInBytes = Width * mBltLibBytesPerPixel;
+
+ Offset = (SourceY * mBltLibWidthInPixels) + SourceX;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemSrc = (VOID *) (mBltLibFrameBuffer + Offset);
+
+ Offset = (DestinationY * mBltLibWidthInPixels) + DestinationX;
+ Offset = mBltLibBytesPerPixel * Offset;
+ BltMemDst = (VOID *) (mBltLibFrameBuffer + Offset);
+
+ LineStride = mBltLibWidthInBytes;
+ if ((UINTN) BltMemDst > (UINTN) BltMemSrc) {
+ LineStride = -LineStride;
+ }
+
+ while (Height > 0) {
+ CopyMem (BltMemDst, BltMemSrc, WidthInBytes);
+
+ BltMemSrc = (VOID*) ((UINT8*) BltMemSrc + LineStride);
+ BltMemDst = (VOID*) ((UINT8*) BltMemDst + LineStride);
+ Height--;
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ Returns the sizes related to the video device
+
+ @param[out] Width Width (in pixels)
+ @param[out] Height Height (in pixels)
+
+ @retval EFI_INVALID_PARAMETER - Invalid parameter passed in
+ @retval EFI_SUCCESS - The sizes were returned
+
+**/
+EFI_STATUS
+EFIAPI
+BltLibGetSizes (
+ OUT UINTN *Width, OPTIONAL
+ OUT UINTN *Height OPTIONAL
+ )
+{
+ if (Width != NULL) {
+ *Width = mBltLibWidthInPixels;
+ }
+ if (Height != NULL) {
+ *Height = mBltLibHeight;
+ }
+
+ return EFI_SUCCESS;
+}
+
diff --git a/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.inf b/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.inf new file mode 100644 index 0000000000..e4da1461d0 --- /dev/null +++ b/OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.inf @@ -0,0 +1,34 @@ +#/** @file
+# FrameBufferBltLib - Library to perform blt operations on a frame buffer.
+#
+# Copyright (c) 2006 - 2011, Intel Corporation
+#
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#**/
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = FrameBufferBltLib
+ FILE_GUID = 2a40f516-c852-4baa-b7a8-0e9ea090d659
+ MODULE_TYPE = BASE
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = BltLib
+
+[Sources.common]
+ FrameBufferBltLib.c
+
+[Libraries]
+ BaseMemoryLib
+ DebugLib
+
+[Packages]
+ MdePkg/MdePkg.dec
+ OptionRomPkg/OptionRomPkg.dec
+
diff --git a/OptionRomPkg/OptionRomPkg.dsc b/OptionRomPkg/OptionRomPkg.dsc index 49979faacc..0570933afd 100644 --- a/OptionRomPkg/OptionRomPkg.dsc +++ b/OptionRomPkg/OptionRomPkg.dsc @@ -96,6 +96,8 @@ ###################################################################################################
[Components]
+ OptionRomPkg/Library/FrameBufferBltLib/FrameBufferBltLib.inf
+
OptionRomPkg/AtapiPassThruDxe/AtapiPassThruDxe.inf
OptionRomPkg/CirrusLogic5430Dxe/CirrusLogic5430Dxe.inf
OptionRomPkg/UndiRuntimeDxe/UndiRuntimeDxe.inf
|