*/
#include "libegint.h"
-#include "refit_call_wrapper.h"
+#include "../refind/global.h"
+#include "../refind/lib.h"
+#include "../refind/screen.h"
+#include "../include/refit_call_wrapper.h"
+#include "lodepng.h"
#define MAX_FILE_SIZE (1024*1024*1024)
+#ifndef __MAKEWITH_GNUEFI
+#define LibLocateHandle gBS->LocateHandleBuffer
+#define LibOpenRoot EfiLibOpenRoot
+#endif
+
//
// Basic image handling
//
EG_IMAGE * egCreateImage(IN UINTN Width, IN UINTN Height, IN BOOLEAN HasAlpha)
{
EG_IMAGE *NewImage;
-
+
NewImage = (EG_IMAGE *) AllocatePool(sizeof(EG_IMAGE));
if (NewImage == NULL)
return NULL;
FreePool(NewImage);
return NULL;
}
-
+
NewImage->Width = Width;
NewImage->Height = Height;
NewImage->HasAlpha = HasAlpha;
EG_IMAGE * egCreateFilledImage(IN UINTN Width, IN UINTN Height, IN BOOLEAN HasAlpha, IN EG_PIXEL *Color)
{
EG_IMAGE *NewImage;
-
+
NewImage = egCreateImage(Width, Height, HasAlpha);
if (NewImage == NULL)
return NULL;
-
+
egFillImage(NewImage, Color);
return NewImage;
}
return NewImage;
}
+// Returns a smaller image composed of the specified crop area from the larger area.
+// If the specified area is larger than is in the original, returns NULL.
+EG_IMAGE * egCropImage(IN EG_IMAGE *Image, IN UINTN StartX, IN UINTN StartY, IN UINTN Width, IN UINTN Height) {
+ EG_IMAGE *NewImage = NULL;
+ UINTN x, y;
+
+ if (((StartX + Width) > Image->Width) || ((StartY + Height) > Image->Height))
+ return NULL;
+
+ NewImage = egCreateImage(Width, Height, Image->HasAlpha);
+ if (NewImage == NULL)
+ return NULL;
+
+ for (y = 0; y < Height; y++) {
+ for (x = 0; x < Width; x++) {
+ NewImage->PixelData[y * NewImage->Width + x] = Image->PixelData[(y + StartY) * Image->Width + x + StartX];
+ }
+ }
+ return NewImage;
+} // EG_IMAGE * egCropImage()
+
VOID egFreeImage(IN EG_IMAGE *Image)
{
if (Image != NULL) {
Status = refit_call5_wrapper(BaseDir->Open, BaseDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);
if (EFI_ERROR(Status)) {
-// Print(L"Returning %d from egLoadFile() because of an error on open!\n", Status);
return Status;
}
FileInfo = LibFileInfo(FileHandle);
if (FileInfo == NULL) {
refit_call1_wrapper(FileHandle->Close, FileHandle);
-// Print(L"LibFileInfo() returned NULL!\n");
return EFI_NOT_FOUND;
}
ReadSize = FileInfo->FileSize;
refit_call1_wrapper(FileHandle->Close, FileHandle);
return EFI_OUT_OF_RESOURCES;
}
-
+
Status = refit_call3_wrapper(FileHandle->Read, FileHandle, &BufferSize, Buffer);
refit_call1_wrapper(FileHandle->Close, FileHandle);
if (EFI_ERROR(Status)) {
*FileData = Buffer;
*FileDataLength = BufferSize;
-// Print(L"In egLoadFile(), Returning EFI_SUCCESS\n");
return EFI_SUCCESS;
}
EFI_STATUS Status;
UINTN HandleCount = 0;
EFI_HANDLE *Handles;
-
+
Status = LibLocateHandle(ByProtocol, &ESPGuid, NULL, &HandleCount, &Handles);
if (!EFI_ERROR(Status) && HandleCount > 0) {
*RootDir = LibOpenRoot(Handles[0]);
return FileName + StrLen(FileName);
}
+// Decode the specified data as the specified format. The IconSize parameter is
+// relevant only for ICNS, for which it selects which ICNS sub-image is decoded.
+// Returns a pointer to the resulting EG_IMAGE or NULL if decoding failed.
static EG_IMAGE * egDecodeAny(IN UINT8 *FileData, IN UINTN FileDataLength,
IN CHAR16 *Format, IN UINTN IconSize, IN BOOLEAN WantAlpha)
{
NewImage = egDecodeBMP(FileData, FileDataLength, IconSize, WantAlpha);
} else if ((StriCmp(Format, L"ICNS") == 0) || (StriCmp(Format, L"icns") == 0)) {
NewImage = egDecodeICNS(FileData, FileDataLength, IconSize, WantAlpha);
+ } else if ((StriCmp(Format, L"PNG") == 0) || (StriCmp(Format, L"png") == 0)) {
+ NewImage = egDecodePNG(FileData, FileDataLength, IconSize, WantAlpha);
} // if/else
return NewImage;
return NewImage;
}
-EG_IMAGE * egLoadIcon(IN EFI_FILE* BaseDir, IN CHAR16 *FileName, IN UINTN IconSize)
+// Load an icon from (BaseDir)/Path, extracting the icon of size IconSize x IconSize.
+// If the initial attempt is unsuccessful, try again, replacing the directory
+// component of Path with DEFAULT_ICONS_DIR.
+// Note: The assumption is that BaseDir points to rEFInd's home directory and Path
+// includes one subdirectory level. If this changes in future revisions, it may be
+// necessary to alter the code that tries again with DEFAULT_ICONS_DIR.
+// Returns a pointer to the image data, or NULL if the icon could not be loaded.
+EG_IMAGE * egLoadIcon(IN EFI_FILE* BaseDir, IN CHAR16 *Path, IN UINTN IconSize)
{
EFI_STATUS Status;
UINT8 *FileData;
UINTN FileDataLength;
+ CHAR16 *FileName, FileName2[256];
EG_IMAGE *NewImage;
- if (BaseDir == NULL || FileName == NULL)
+ if (BaseDir == NULL || Path == NULL)
return NULL;
// load file
- Status = egLoadFile(BaseDir, FileName, &FileData, &FileDataLength);
+ Status = egLoadFile(BaseDir, Path, &FileData, &FileDataLength);
if (EFI_ERROR(Status)) {
-// Print(L"In egLoadIcon(), Status = %d after egLoadFile(); aborting load!\n", Status);
- return NULL;
+ FileName = Basename(Path); // Note: FileName is a pointer within Path; DON'T FREE IT!
+ SPrint(FileName2, 255, L"%s\\%s", DEFAULT_ICONS_DIR, FileName);
+ Status = egLoadFile(BaseDir, FileName2, &FileData, &FileDataLength);
+ if (EFI_ERROR(Status))
+ return NULL;
}
// decode it
- NewImage = egDecodeAny(FileData, FileDataLength, egFindExtension(FileName), IconSize, TRUE);
-// Print(L"Done with egDecodeAny(), used extension '%s'\n", egFindExtension(FileName));
-// if (NewImage == NULL)
-// Print(L"Returning NULL from egLoadIcon()\n");
+ NewImage = egDecodeAny(FileData, FileDataLength, egFindExtension(Path), IconSize, TRUE);
FreePool(FileData);
+ if ((NewImage->Width != IconSize) || (NewImage->Height != IconSize)) {
+ Print(L"Warning: Attempt to load icon of the wrong size from '%s'\n", Path);
+ MyFreePool(NewImage);
+ NewImage = NULL;
+ }
return NewImage;
-}
+} // EG_IMAGE *egLoadIcon()
EG_IMAGE * egDecodeImage(IN UINT8 *FileData, IN UINTN FileDataLength, IN CHAR16 *Format, IN BOOLEAN WantAlpha)
{
UINT8 *CompData;
UINTN CompLen;
UINTN PixelCount;
-
+
// sanity check
if (EmbeddedImage->PixelMode > EG_MAX_EIPIXELMODE ||
(EmbeddedImage->CompressMode != EG_EICOMPMODE_NONE && EmbeddedImage->CompressMode != EG_EICOMPMODE_RLE))
return NULL;
-
+
// allocate image structure and pixel buffer
NewImage = egCreateImage(EmbeddedImage->Width, EmbeddedImage->Height, WantAlpha);
if (NewImage == NULL)
return NULL;
-
+
CompData = (UINT8 *)EmbeddedImage->Data; // drop const
CompLen = EmbeddedImage->DataLength;
PixelCount = EmbeddedImage->Width * EmbeddedImage->Height;
-
+
// FUTURE: for EG_EICOMPMODE_EFICOMPRESS, decompress whole data block here
-
+
if (EmbeddedImage->PixelMode == EG_EIPIXELMODE_GRAY ||
EmbeddedImage->PixelMode == EG_EIPIXELMODE_GRAY_ALPHA) {
-
+
// copy grayscale plane and expand
if (EmbeddedImage->CompressMode == EG_EICOMPMODE_RLE) {
egDecompressIcnsRLE(&CompData, &CompLen, PLPTR(NewImage, r), PixelCount);
}
egCopyPlane(PLPTR(NewImage, r), PLPTR(NewImage, g), PixelCount);
egCopyPlane(PLPTR(NewImage, r), PLPTR(NewImage, b), PixelCount);
-
+
} else if (EmbeddedImage->PixelMode == EG_EIPIXELMODE_COLOR ||
EmbeddedImage->PixelMode == EG_EIPIXELMODE_COLOR_ALPHA) {
-
+
// copy color planes
if (EmbeddedImage->CompressMode == EG_EICOMPMODE_RLE) {
egDecompressIcnsRLE(&CompData, &CompLen, PLPTR(NewImage, r), PixelCount);
egInsertPlane(CompData, PLPTR(NewImage, b), PixelCount);
CompData += PixelCount;
}
-
+
} else {
-
+
// set color planes to black
egSetPlane(PLPTR(NewImage, r), 0, PixelCount);
egSetPlane(PLPTR(NewImage, g), 0, PixelCount);
egSetPlane(PLPTR(NewImage, b), 0, PixelCount);
-
+
}
-
+
if (WantAlpha && (EmbeddedImage->PixelMode == EG_EIPIXELMODE_GRAY_ALPHA ||
EmbeddedImage->PixelMode == EG_EIPIXELMODE_COLOR_ALPHA ||
EmbeddedImage->PixelMode == EG_EIPIXELMODE_ALPHA)) {
-
+
// copy alpha plane
if (EmbeddedImage->CompressMode == EG_EICOMPMODE_RLE) {
egDecompressIcnsRLE(&CompData, &CompLen, PLPTR(NewImage, a), PixelCount);
egInsertPlane(CompData, PLPTR(NewImage, a), PixelCount);
CompData += PixelCount;
}
-
+
} else {
egSetPlane(PLPTR(NewImage, a), WantAlpha ? 255 : 0, PixelCount);
}
-
+
return NewImage;
}
UINTN i;
EG_PIXEL FillColor;
EG_PIXEL *PixelPtr;
-
+
FillColor = *Color;
if (!CompImage->HasAlpha)
FillColor.a = 0;
-
+
PixelPtr = CompImage->PixelData;
for (i = 0; i < CompImage->Width * CompImage->Height; i++, PixelPtr++)
*PixelPtr = FillColor;
EG_PIXEL FillColor;
EG_PIXEL *PixelPtr;
EG_PIXEL *PixelBasePtr;
-
+
egRestrictImageArea(CompImage, AreaPosX, AreaPosY, &AreaWidth, &AreaHeight);
-
+
if (AreaWidth > 0) {
FillColor = *Color;
if (!CompImage->HasAlpha)
FillColor.a = 0;
-
+
PixelBasePtr = CompImage->PixelData + AreaPosY * CompImage->Width + AreaPosX;
for (y = 0; y < AreaHeight; y++) {
PixelPtr = PixelBasePtr;
{
UINTN x, y;
EG_PIXEL *TopPtr, *CompPtr;
-
+
for (y = 0; y < Height; y++) {
TopPtr = TopBasePtr;
CompPtr = CompBasePtr;
UINTN Alpha;
UINTN RevAlpha;
UINTN Temp;
-
+
for (y = 0; y < Height; y++) {
TopPtr = TopBasePtr;
CompPtr = CompBasePtr;
VOID egComposeImage(IN OUT EG_IMAGE *CompImage, IN EG_IMAGE *TopImage, IN UINTN PosX, IN UINTN PosY)
{
UINTN CompWidth, CompHeight;
-
+
CompWidth = TopImage->Width;
CompHeight = TopImage->Height;
egRestrictImageArea(CompImage, PosX, PosY, &CompWidth, &CompHeight);
-
+
// compose
if (CompWidth > 0) {
- if (CompImage->HasAlpha) {
- CompImage->HasAlpha = FALSE;
- egSetPlane(PLPTR(CompImage, a), 0, CompImage->Width * CompImage->Height);
- }
-
- if (TopImage->HasAlpha)
+// if (CompImage->HasAlpha) {
+// CompImage->HasAlpha = FALSE;
+// egSetPlane(PLPTR(CompImage, a), 0, CompImage->Width * CompImage->Height);
+// }
+
+ if (TopImage->HasAlpha) {
egRawCompose(CompImage->PixelData + PosY * CompImage->Width + PosX, TopImage->PixelData,
CompWidth, CompHeight, CompImage->Width, TopImage->Width);
- else
+ } else {
egRawCopy(CompImage->PixelData + PosY * CompImage->Width + PosX, TopImage->PixelData,
CompWidth, CompHeight, CompImage->Width, TopImage->Width);
+ }
}
}
return NULL;
if (Image->Width == Width && Image->Height == Height)
return Image;
-
+
NewImage = egCreateFilledImage(Width, Height, Image->HasAlpha, Color);
if (NewImage == NULL) {
egFreeImage(Image);
}
egComposeImage(NewImage, Image, 0, 0);
egFreeImage(Image);
-
+
return NewImage;
}
VOID egInsertPlane(IN UINT8 *SrcDataPtr, IN UINT8 *DestPlanePtr, IN UINTN PixelCount)
{
UINTN i;
-
+
for (i = 0; i < PixelCount; i++) {
*DestPlanePtr = *SrcDataPtr++;
DestPlanePtr += 4;
VOID egSetPlane(IN UINT8 *DestPlanePtr, IN UINT8 Value, IN UINTN PixelCount)
{
UINTN i;
-
+
for (i = 0; i < PixelCount; i++) {
*DestPlanePtr = Value;
DestPlanePtr += 4;
VOID egCopyPlane(IN UINT8 *SrcPlanePtr, IN UINT8 *DestPlanePtr, IN UINTN PixelCount)
{
UINTN i;
-
+
for (i = 0; i < PixelCount; i++) {
*DestPlanePtr = *SrcPlanePtr;
DestPlanePtr += 4, SrcPlanePtr += 4;