/** @file\r
+Implementation for EFI_HII_IMAGE_PROTOCOL.\r
\r
-Copyright (c) 2007 - 2008, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
+\r
+Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
-Module Name:\r
-\r
- Image.c\r
-\r
-Abstract:\r
-\r
- Implementation for EFI_HII_IMAGE_PROTOCOL.\r
-\r
-Revision History\r
-\r
-\r
**/\r
\r
\r
#include "HiiDatabase.h"\r
\r
-#ifndef DISABLE_UNUSED_HII_PROTOCOLS\r
\r
-STATIC\r
-UINT8*\r
-GetImageIdOrAddress (\r
- IN UINT8 *ImageBlock,\r
- IN OUT EFI_IMAGE_ID *ImageId\r
- )\r
-/*++\r
+/**\r
+ Get the imageid of last image block: EFI_HII_IIBT_END_BLOCK when input\r
+ ImageId is zero, otherwise return the address of the\r
+ corresponding image block with identifier specified by ImageId.\r
\r
- Routine Description:\r
- Get the imageid of last image block: EFI_HII_IIBT_END_BLOCK when input\r
- ImageId is zero, otherwise return the address of the\r
- corresponding image block with identifier specified by ImageId.\r
+ This is a internal function.\r
\r
- Arguments:\r
- ImageBlock - Points to the beginning of a series of image blocks stored in order.\r
- ImageId - If input ImageId is 0, output the image id of the EFI_HII_IIBT_END_BLOCK;\r
- else use this id to find its corresponding image block address.\r
+ @param ImageBlocks Points to the beginning of a series of image blocks stored in order.\r
+ @param ImageId If input ImageId is 0, output the image id of the EFI_HII_IIBT_END_BLOCK;\r
+ else use this id to find its corresponding image block address.\r
\r
- Returns:\r
- The image block address when input ImageId is not zero; otherwise return NULL.\r
+ @return The image block address when input ImageId is not zero; otherwise return NULL.\r
\r
---*/\r
+**/\r
+EFI_HII_IMAGE_BLOCK *\r
+GetImageIdOrAddress (\r
+ IN EFI_HII_IMAGE_BLOCK *ImageBlocks,\r
+ IN OUT EFI_IMAGE_ID *ImageId\r
+ )\r
{\r
EFI_IMAGE_ID ImageIdCurrent;\r
- UINT8 *ImageBlockHdr;\r
- UINT8 Length8;\r
- UINT16 Length16;\r
- UINT32 Length32;\r
- EFI_HII_IIBT_IMAGE_1BIT_BLOCK Iibt1bit;\r
- EFI_HII_IIBT_IMAGE_4BIT_BLOCK Iibt4bit;\r
- EFI_HII_IIBT_IMAGE_8BIT_BLOCK Iibt8bit;\r
- UINT16 Width;\r
- UINT16 Height;\r
-\r
- ASSERT (ImageBlock != NULL && ImageId != NULL);\r
-\r
- ImageBlockHdr = ImageBlock;\r
- ImageIdCurrent = 1;\r
-\r
- while (((EFI_HII_IMAGE_BLOCK *) ImageBlock)->BlockType != EFI_HII_IIBT_END) {\r
- if (*ImageId > 0) {\r
+ EFI_HII_IMAGE_BLOCK *CurrentImageBlock;\r
+ UINTN Length;\r
+\r
+ ASSERT (ImageBlocks != NULL && ImageId != NULL);\r
+ CurrentImageBlock = ImageBlocks;\r
+ ImageIdCurrent = 1;\r
+\r
+ while (CurrentImageBlock->BlockType != EFI_HII_IIBT_END) {\r
+ if (*ImageId != 0) {\r
if (*ImageId == ImageIdCurrent) {\r
//\r
// If the found image block is a duplicate block, update the ImageId to\r
// find the previous defined image block.\r
//\r
- if (((EFI_HII_IMAGE_BLOCK *) ImageBlock)->BlockType == EFI_HII_IIBT_DUPLICATE) {\r
- CopyMem (ImageId, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (EFI_IMAGE_ID));\r
+ if (CurrentImageBlock->BlockType == EFI_HII_IIBT_DUPLICATE) {\r
+ *ImageId = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_DUPLICATE_BLOCK *) CurrentImageBlock)->ImageId);\r
ASSERT (*ImageId != ImageIdCurrent);\r
- ImageBlock = ImageBlockHdr;\r
+ ASSERT (*ImageId != 0);\r
+ CurrentImageBlock = ImageBlocks;\r
ImageIdCurrent = 1;\r
continue;\r
}\r
\r
- return ImageBlock;\r
+ return CurrentImageBlock;\r
}\r
if (*ImageId < ImageIdCurrent) {\r
//\r
return NULL;\r
}\r
}\r
- switch (((EFI_HII_IMAGE_BLOCK *) ImageBlock)->BlockType) {\r
+ switch (CurrentImageBlock->BlockType) {\r
case EFI_HII_IIBT_EXT1:\r
- Length8 = *(ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT8));\r
- ImageBlock += Length8;\r
- ImageIdCurrent++;\r
+ Length = ((EFI_HII_IIBT_EXT1_BLOCK *) CurrentImageBlock)->Length;\r
break;\r
case EFI_HII_IIBT_EXT2:\r
- CopyMem (\r
- &Length16,\r
- ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT8),\r
- sizeof (UINT16)\r
- );\r
- ImageBlock += Length16;\r
- ImageIdCurrent++;\r
+ Length = ReadUnaligned16 (&((EFI_HII_IIBT_EXT2_BLOCK *) CurrentImageBlock)->Length);\r
break;\r
case EFI_HII_IIBT_EXT4:\r
- CopyMem (\r
- &Length32,\r
- ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT8),\r
- sizeof (UINT32)\r
- );\r
- ImageBlock += Length32;\r
- ImageIdCurrent++;\r
+ Length = ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_EXT4_BLOCK *) CurrentImageBlock)->Length);\r
break;\r
\r
case EFI_HII_IIBT_IMAGE_1BIT:\r
case EFI_HII_IIBT_IMAGE_1BIT_TRANS:\r
- CopyMem (&Iibt1bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK));\r
- ImageBlock += sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8) +\r
- BITMAP_LEN_1_BIT (Iibt1bit.Bitmap.Width, Iibt1bit.Bitmap.Height);\r
+ Length = sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8) +\r
+ BITMAP_LEN_1_BIT (\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)\r
+ );\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_IMAGE_4BIT:\r
case EFI_HII_IIBT_IMAGE_4BIT_TRANS:\r
- CopyMem (&Iibt4bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK));\r
- ImageBlock += sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8) +\r
- BITMAP_LEN_4_BIT (Iibt4bit.Bitmap.Width, Iibt4bit.Bitmap.Height);\r
+ Length = sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8) +\r
+ BITMAP_LEN_4_BIT (\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_4BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_4BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)\r
+ );\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_IMAGE_8BIT:\r
case EFI_HII_IIBT_IMAGE_8BIT_TRANS:\r
- CopyMem (&Iibt8bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK));\r
- ImageBlock += sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +\r
- BITMAP_LEN_8_BIT (Iibt8bit.Bitmap.Width, Iibt8bit.Bitmap.Height);\r
+ Length = sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +\r
+ BITMAP_LEN_8_BIT (\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),\r
+ ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)\r
+ );\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_IMAGE_24BIT:\r
case EFI_HII_IIBT_IMAGE_24BIT_TRANS:\r
- CopyMem (&Width, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (UINT16));\r
- CopyMem (\r
- &Height,\r
- ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT16),\r
- sizeof (UINT16)\r
- );\r
- ImageBlock += sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +\r
- BITMAP_LEN_24_BIT (Width, Height);\r
+ Length = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +\r
+ BITMAP_LEN_24_BIT (\r
+ ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),\r
+ ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)\r
+ );\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_DUPLICATE:\r
- ImageBlock += sizeof (EFI_HII_IIBT_DUPLICATE_BLOCK);\r
+ Length = sizeof (EFI_HII_IIBT_DUPLICATE_BLOCK);\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_IMAGE_JPEG:\r
- CopyMem (&Length32, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (UINT32));\r
- ImageBlock += Length32;\r
+ Length = ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size);\r
ImageIdCurrent++;\r
break;\r
\r
case EFI_HII_IIBT_SKIP1:\r
- Length8 = *(ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK));\r
- ImageBlock += sizeof (EFI_HII_IIBT_SKIP1_BLOCK);\r
- ImageIdCurrent = (UINT16) (ImageIdCurrent + Length8);\r
+ Length = sizeof (EFI_HII_IIBT_SKIP1_BLOCK);\r
+ ImageIdCurrent += ((EFI_HII_IIBT_SKIP1_BLOCK *) CurrentImageBlock)->SkipCount;\r
break;\r
\r
case EFI_HII_IIBT_SKIP2:\r
- CopyMem (&Length16, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (UINT16));\r
- ImageBlock += sizeof (EFI_HII_IIBT_SKIP2_BLOCK);\r
- ImageIdCurrent = (UINT16) (ImageIdCurrent + Length16);\r
+ Length = sizeof (EFI_HII_IIBT_SKIP2_BLOCK);\r
+ ImageIdCurrent += ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_SKIP2_BLOCK *) CurrentImageBlock)->SkipCount);\r
break;\r
\r
default:\r
// Unknown image blocks can not be skipped, processing halts.\r
//\r
ASSERT (FALSE);\r
+ Length = 0;\r
+ break;\r
}\r
+\r
+ CurrentImageBlock = (EFI_HII_IMAGE_BLOCK *) ((UINT8 *) CurrentImageBlock + Length);\r
+\r
}\r
\r
//\r
//\r
if (*ImageId == 0) {\r
*ImageId = ImageIdCurrent;\r
- return ImageBlock;\r
+ return CurrentImageBlock;\r
}\r
\r
return NULL;\r
/**\r
Convert pixels from EFI_GRAPHICS_OUTPUT_BLT_PIXEL to EFI_HII_RGB_PIXEL style.\r
\r
+ This is a internal function.\r
+\r
+\r
@param BitMapOut Pixels in EFI_HII_RGB_PIXEL format.\r
@param BitMapIn Pixels in EFI_GRAPHICS_OUTPUT_BLT_PIXEL format.\r
@param PixelNum The number of pixels to be converted.\r
\r
\r
**/\r
-STATIC\r
VOID\r
CopyGopToRgbPixel (\r
OUT EFI_HII_RGB_PIXEL *BitMapOut,\r
/**\r
Convert pixels from EFI_HII_RGB_PIXEL to EFI_GRAPHICS_OUTPUT_BLT_PIXEL style.\r
\r
+ This is a internal function.\r
+\r
+\r
@param BitMapOut Pixels in EFI_GRAPHICS_OUTPUT_BLT_PIXEL format.\r
@param BitMapIn Pixels in EFI_HII_RGB_PIXEL format.\r
@param PixelNum The number of pixels to be converted.\r
\r
\r
**/\r
-STATIC\r
VOID\r
CopyRgbToGopPixel (\r
OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapOut,\r
/**\r
Output pixels in "1 bit per pixel" format to an image.\r
\r
+ This is a internal function.\r
+\r
+\r
@param Image Points to the image which will store the pixels.\r
@param Data Stores the value of output pixels, 0 or 1.\r
@param PaletteInfo PaletteInfo which stores the color of the output\r
\r
\r
**/\r
-STATIC\r
VOID\r
Output1bitPixel (\r
IN OUT EFI_IMAGE_INPUT *Image,\r
IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo\r
)\r
{\r
- UINT16 X;\r
- UINT16 Y;\r
+ UINT16 Xpos;\r
+ UINT16 Ypos;\r
UINTN OffsetY;\r
UINT8 Index;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[2];\r
EFI_HII_IMAGE_PALETTE_INFO *Palette;\r
- UINT16 PaletteSize;\r
+ UINTN PaletteSize;\r
UINT8 Byte;\r
\r
ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);\r
//\r
// First entry corresponds to color 0 and second entry corresponds to color 1.\r
//\r
+ PaletteSize = 0;\r
CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
PaletteSize += sizeof (UINT16);\r
Palette = AllocateZeroPool (PaletteSize);\r
ASSERT (Palette != NULL);\r
+ if (Palette == NULL) {\r
+ return;\r
+ }\r
CopyMem (Palette, PaletteInfo, PaletteSize);\r
\r
ZeroMem (PaletteValue, sizeof (PaletteValue));\r
CopyRgbToGopPixel (&PaletteValue[0], &Palette->PaletteValue[0], 1);\r
CopyRgbToGopPixel (&PaletteValue[1], &Palette->PaletteValue[1], 1);\r
- SafeFreePool (Palette);\r
+ FreePool (Palette);\r
\r
//\r
// Convert the pixel from one bit to corresponding color.\r
//\r
- for (Y = 0; Y < Image->Height; Y++) {\r
- OffsetY = BITMAP_LEN_1_BIT (Image->Width, Y);\r
+ for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
+ OffsetY = BITMAP_LEN_1_BIT (Image->Width, Ypos);\r
//\r
// All bits in these bytes are meaningful\r
//\r
- for (X = 0; X < Image->Width / 8; X++) {\r
- Byte = *(Data + OffsetY + X);\r
+ for (Xpos = 0; Xpos < Image->Width / 8; Xpos++) {\r
+ Byte = *(Data + OffsetY + Xpos);\r
for (Index = 0; Index < 8; Index++) {\r
if ((Byte & (1 << Index)) != 0) {\r
- BitMapPtr[Y * Image->Width + X * 8 + (8 - Index - 1)] = PaletteValue[1];\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[1];\r
} else {\r
- BitMapPtr[Y * Image->Width + X * 8 + (8 - Index - 1)] = PaletteValue[0];\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[0];\r
}\r
}\r
}\r
//\r
// Padding bits in this byte should be ignored.\r
//\r
- Byte = *(Data + OffsetY + X);\r
+ Byte = *(Data + OffsetY + Xpos);\r
for (Index = 0; Index < Image->Width % 8; Index++) {\r
if ((Byte & (1 << (8 - Index - 1))) != 0) {\r
- BitMapPtr[Y * Image->Width + X * 8 + Index] = PaletteValue[1];\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[1];\r
} else {\r
- BitMapPtr[Y * Image->Width + X * 8 + Index] = PaletteValue[0];\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[0];\r
}\r
}\r
}\r
/**\r
Output pixels in "4 bit per pixel" format to an image.\r
\r
+ This is a internal function.\r
+\r
+\r
@param Image Points to the image which will store the pixels.\r
@param Data Stores the value of output pixels, 0 ~ 15.\r
- @param PaletteInfo PaletteInfo which stores the color of the output\r
+ @param[in] PaletteInfo PaletteInfo which stores the color of the output\r
pixels. Each entry corresponds to a color within\r
[0, 15].\r
\r
\r
**/\r
-STATIC\r
VOID\r
Output4bitPixel (\r
IN OUT EFI_IMAGE_INPUT *Image,\r
IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo\r
)\r
{\r
- UINT16 X;\r
- UINT16 Y;\r
+ UINT16 Xpos;\r
+ UINT16 Ypos;\r
UINTN OffsetY;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[16];\r
EFI_HII_IMAGE_PALETTE_INFO *Palette;\r
- UINT16 PaletteSize;\r
+ UINTN PaletteSize;\r
UINT16 PaletteNum;\r
UINT8 Byte;\r
\r
//\r
// The bitmap should allocate each color index starting from 0.\r
//\r
+ PaletteSize = 0;\r
CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
PaletteSize += sizeof (UINT16);\r
Palette = AllocateZeroPool (PaletteSize);\r
ASSERT (Palette != NULL);\r
+ if (Palette == NULL) {\r
+ return;\r
+ }\r
CopyMem (Palette, PaletteInfo, PaletteSize);\r
PaletteNum = (UINT16)(Palette->PaletteSize / sizeof (EFI_HII_RGB_PIXEL));\r
\r
ZeroMem (PaletteValue, sizeof (PaletteValue));\r
CopyRgbToGopPixel (PaletteValue, Palette->PaletteValue, PaletteNum);\r
- SafeFreePool (Palette);\r
+ FreePool (Palette);\r
\r
//\r
// Convert the pixel from 4 bit to corresponding color.\r
//\r
- for (Y = 0; Y < Image->Height; Y++) {\r
- OffsetY = BITMAP_LEN_4_BIT (Image->Width, Y);\r
+ for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
+ OffsetY = BITMAP_LEN_4_BIT (Image->Width, Ypos);\r
//\r
// All bits in these bytes are meaningful\r
//\r
- for (X = 0; X < Image->Width / 2; X++) {\r
- Byte = *(Data + OffsetY + X);\r
- BitMapPtr[Y * Image->Width + X * 2] = PaletteValue[Byte >> 4];\r
- BitMapPtr[Y * Image->Width + X * 2 + 1] = PaletteValue[Byte & 0x0F];\r
+ for (Xpos = 0; Xpos < Image->Width / 2; Xpos++) {\r
+ Byte = *(Data + OffsetY + Xpos);\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 2] = PaletteValue[Byte >> 4];\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 2 + 1] = PaletteValue[Byte & 0x0F];\r
}\r
\r
if (Image->Width % 2 != 0) {\r
//\r
// Padding bits in this byte should be ignored.\r
//\r
- Byte = *(Data + OffsetY + X);\r
- BitMapPtr[Y * Image->Width + X * 2] = PaletteValue[Byte >> 4];\r
+ Byte = *(Data + OffsetY + Xpos);\r
+ BitMapPtr[Ypos * Image->Width + Xpos * 2] = PaletteValue[Byte >> 4];\r
}\r
}\r
}\r
/**\r
Output pixels in "8 bit per pixel" format to an image.\r
\r
+ This is a internal function.\r
+\r
+\r
@param Image Points to the image which will store the pixels.\r
@param Data Stores the value of output pixels, 0 ~ 255.\r
- @param PaletteInfo PaletteInfo which stores the color of the output\r
+ @param[in] PaletteInfo PaletteInfo which stores the color of the output\r
pixels. Each entry corresponds to a color within\r
[0, 255].\r
\r
\r
**/\r
-STATIC\r
VOID\r
Output8bitPixel (\r
IN OUT EFI_IMAGE_INPUT *Image,\r
IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo\r
)\r
{\r
- UINT16 X;\r
- UINT16 Y;\r
+ UINT16 Xpos;\r
+ UINT16 Ypos;\r
UINTN OffsetY;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[256];\r
EFI_HII_IMAGE_PALETTE_INFO *Palette;\r
- UINT16 PaletteSize;\r
+ UINTN PaletteSize;\r
UINT16 PaletteNum;\r
UINT8 Byte;\r
\r
//\r
// The bitmap should allocate each color index starting from 0.\r
//\r
+ PaletteSize = 0;\r
CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
PaletteSize += sizeof (UINT16);\r
Palette = AllocateZeroPool (PaletteSize);\r
ASSERT (Palette != NULL);\r
+ if (Palette == NULL) {\r
+ return;\r
+ }\r
CopyMem (Palette, PaletteInfo, PaletteSize);\r
PaletteNum = (UINT16)(Palette->PaletteSize / sizeof (EFI_HII_RGB_PIXEL));\r
ZeroMem (PaletteValue, sizeof (PaletteValue));\r
CopyRgbToGopPixel (PaletteValue, Palette->PaletteValue, PaletteNum);\r
- SafeFreePool (Palette);\r
+ FreePool (Palette);\r
\r
//\r
// Convert the pixel from 8 bits to corresponding color.\r
//\r
- for (Y = 0; Y < Image->Height; Y++) {\r
- OffsetY = BITMAP_LEN_8_BIT (Image->Width, Y);\r
+ for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
+ OffsetY = BITMAP_LEN_8_BIT (Image->Width, Ypos);\r
//\r
// All bits are meaningful since the bitmap is 8 bits per pixel.\r
//\r
- for (X = 0; X < Image->Width; X++) {\r
- Byte = *(Data + OffsetY + X);\r
- BitMapPtr[OffsetY + X] = PaletteValue[Byte];\r
+ for (Xpos = 0; Xpos < Image->Width; Xpos++) {\r
+ Byte = *(Data + OffsetY + Xpos);\r
+ BitMapPtr[OffsetY + Xpos] = PaletteValue[Byte];\r
}\r
}\r
\r
/**\r
Output pixels in "24 bit per pixel" format to an image.\r
\r
+ This is a internal function.\r
+\r
+\r
@param Image Points to the image which will store the pixels.\r
@param Data Stores the color of output pixels, allowing 16.8\r
millions colors.\r
\r
\r
**/\r
-STATIC\r
VOID\r
Output24bitPixel (\r
IN OUT EFI_IMAGE_INPUT *Image,\r
IN EFI_HII_RGB_PIXEL *Data\r
)\r
{\r
- UINT16 Y;\r
+ UINT16 Ypos;\r
UINTN OffsetY;\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;\r
\r
\r
BitMapPtr = Image->Bitmap;\r
\r
- for (Y = 0; Y < Image->Height; Y++) {\r
- OffsetY = BITMAP_LEN_8_BIT (Image->Width, Y);\r
+ for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
+ OffsetY = BITMAP_LEN_8_BIT (Image->Width, Ypos);\r
CopyRgbToGopPixel (&BitMapPtr[OffsetY], &Data[OffsetY], Image->Width);\r
}\r
\r
/**\r
Convert the image from EFI_IMAGE_INPUT to EFI_IMAGE_OUTPUT format.\r
\r
+ This is a internal function.\r
+\r
+\r
@param BltBuffer Buffer points to bitmap data of incoming image.\r
+ @param BltX Specifies the offset from the left and top edge of\r
+ the output image of the first pixel in the image.\r
@param BltY Specifies the offset from the left and top edge of\r
the output image of the first pixel in the image.\r
@param Width Width of the incoming image, in pixels.\r
@retval EFI_INVALID_PARAMETER Any incoming parameter is invalid.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ImageToBlt (\r
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,\r
)\r
{\r
EFI_IMAGE_OUTPUT *ImageOut;\r
- UINTN X;\r
- UINTN Y;\r
+ UINTN Xpos;\r
+ UINTN Ypos;\r
UINTN OffsetY1; // src buffer\r
UINTN OffsetY2; // dest buffer\r
EFI_GRAPHICS_OUTPUT_BLT_PIXEL SrcPixel;\r
\r
ZeroMem (&ZeroPixel, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));\r
\r
- for (Y = 0; Y < Height; Y++) {\r
- OffsetY1 = Width * Y;\r
- OffsetY2 = ImageOut->Width * (BltY + Y);\r
- for (X = 0; X < Width; X++) {\r
- SrcPixel = BltBuffer[OffsetY1 + X];\r
+ for (Ypos = 0; Ypos < Height; Ypos++) {\r
+ OffsetY1 = Width * Ypos;\r
+ OffsetY2 = ImageOut->Width * (BltY + Ypos);\r
+ for (Xpos = 0; Xpos < Width; Xpos++) {\r
+ SrcPixel = BltBuffer[OffsetY1 + Xpos];\r
if (Transparent) {\r
if (CompareMem (&SrcPixel, &ZeroPixel, 3) != 0) {\r
- ImageOut->Image.Bitmap[OffsetY2 + BltX + X] = SrcPixel;\r
+ ImageOut->Image.Bitmap[OffsetY2 + BltX + Xpos] = SrcPixel;\r
}\r
} else {\r
- ImageOut->Image.Bitmap[OffsetY2 + BltX + X] = SrcPixel;\r
+ ImageOut->Image.Bitmap[OffsetY2 + BltX + Xpos] = SrcPixel;\r
}\r
}\r
}\r
return EFI_SUCCESS;\r
}\r
\r
+/**\r
+ Return the HII package list identified by PackageList HII handle.\r
+\r
+ @param Database Pointer to HII database list header.\r
+ @param PackageList HII handle of the package list to locate.\r
+\r
+ @retval The HII package list instance.\r
+**/\r
+HII_DATABASE_PACKAGE_LIST_INSTANCE *\r
+LocatePackageList (\r
+ IN LIST_ENTRY *Database,\r
+ IN EFI_HII_HANDLE PackageList\r
+ )\r
+{\r
+ LIST_ENTRY *Link;\r
+ HII_DATABASE_RECORD *Record;\r
+\r
+ //\r
+ // Get the specified package list and image package.\r
+ //\r
+ for (Link = GetFirstNode (Database);\r
+ !IsNull (Database, Link);\r
+ Link = GetNextNode (Database, Link)\r
+ ) {\r
+ Record = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
+ if (Record->Handle == PackageList) {\r
+ return Record->PackageList;\r
+ }\r
+ }\r
+ return NULL;\r
+}\r
\r
/**\r
This function adds the image Image to the group of images owned by PackageList, and returns\r
)\r
{\r
HII_DATABASE_PRIVATE_DATA *Private;\r
- LIST_ENTRY *Link;\r
- HII_DATABASE_RECORD *DatabaseRecord;\r
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;\r
HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;\r
UINT8 *ImageBlock;\r
}\r
\r
Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
-\r
- //\r
- // Get the specified package list\r
- //\r
-\r
- PackageListNode = NULL;\r
-\r
- for (Link = Private->DatabaseList.ForwardLink;\r
- Link != &Private->DatabaseList;\r
- Link = Link->ForwardLink\r
- ) {\r
- DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
- if (DatabaseRecord->Handle == PackageList) {\r
- PackageListNode = DatabaseRecord->PackageList;\r
- break;\r
- }\r
- }\r
-\r
+ PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);\r
if (PackageListNode == NULL) {\r
return EFI_NOT_FOUND;\r
}\r
ImagePackage->ImageBlock,\r
ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)\r
);\r
- SafeFreePool (ImagePackage->ImageBlock);\r
- ImagePackage->ImageBlock = ImageBlock;\r
+ FreePool (ImagePackage->ImageBlock);\r
+ ImagePackage->ImageBlock = (EFI_HII_IMAGE_BLOCK *) ImageBlock;\r
ImageBlock += ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK);\r
//\r
// Temp memory to store new block.\r
//\r
NewBlock = AllocateZeroPool (NewBlockSize);\r
if (NewBlock == NULL) {\r
- SafeFreePool (ImagePackage->ImageBlock);\r
- ImagePackage->ImageBlock = NULL;\r
+ FreePool (ImagePackage->ImageBlock);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
NewBlockPtr = NewBlock;\r
// Fill in image blocks.\r
//\r
ImagePackage->ImageBlockSize = (UINT32) BlockSize;\r
- ImagePackage->ImageBlock = (UINT8 *) AllocateZeroPool (BlockSize);\r
+ ImagePackage->ImageBlock = AllocateZeroPool (BlockSize);\r
if (ImagePackage->ImageBlock == NULL) {\r
- SafeFreePool (ImagePackage);\r
+ FreePool (ImagePackage);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
- ImageBlock = ImagePackage->ImageBlock;\r
+ ImageBlock = (UINT8 *) ImagePackage->ImageBlock;\r
\r
//\r
// Temp memory to store new block.\r
//\r
NewBlock = AllocateZeroPool (NewBlockSize);\r
if (NewBlock == NULL) {\r
- SafeFreePool (ImagePackage->ImageBlock);\r
- SafeFreePool (ImagePackage);\r
+ FreePool (ImagePackage->ImageBlock);\r
+ FreePool (ImagePackage);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
NewBlockPtr = NewBlock;\r
CopyGopToRgbPixel ((EFI_HII_RGB_PIXEL *) NewBlock, ImageIn->Bitmap, ImageIn->Width * ImageIn->Height);\r
\r
CopyMem (ImageBlock, NewBlockPtr, NewBlockSize);\r
- SafeFreePool (NewBlockPtr);\r
+ FreePool (NewBlockPtr);\r
\r
//\r
// Append the block end\r
ImageBlock += NewBlockSize;\r
((EFI_HII_IIBT_END_BLOCK *) (ImageBlock))->Header.BlockType = EFI_HII_IIBT_END;\r
\r
+ //\r
+ // Check whether need to get the contents of HiiDataBase.\r
+ // Only after ReadyToBoot to do the export.\r
+ //\r
+ if (gExportAfterReadyToBoot) {\r
+ HiiGetDatabaseInfo(&Private->HiiDatabase);\r
+ }\r
+\r
return EFI_SUCCESS;\r
}\r
\r
@param ImageId The image's id,, which is unique within\r
PackageList.\r
@param Image Points to the image.\r
- @param ImageSize On entry, points to the size of the buffer pointed\r
- to by Image, in bytes. On return, points to the\r
- length of the image, in bytes.\r
\r
@retval EFI_SUCCESS The new image was returned successfully.\r
@retval EFI_NOT_FOUND The image specified by ImageId is not in the\r
)\r
{\r
HII_DATABASE_PRIVATE_DATA *Private;\r
- LIST_ENTRY *Link;\r
- HII_DATABASE_RECORD *DatabaseRecord;\r
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;\r
HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;\r
UINT8 *ImageBlock;\r
}\r
\r
Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
-\r
- //\r
- // Get the specified package list and image package.\r
- //\r
- PackageListNode = NULL;\r
- for (Link = Private->DatabaseList.ForwardLink;\r
- Link != &Private->DatabaseList;\r
- Link = Link->ForwardLink\r
- ) {\r
- DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
- if (DatabaseRecord->Handle == PackageList) {\r
- PackageListNode = DatabaseRecord->PackageList;\r
- break;\r
- }\r
- }\r
+ PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);\r
if (PackageListNode == NULL) {\r
return EFI_NOT_FOUND;\r
}\r
// Find the image block specified by ImageId\r
//\r
LocalImageId = ImageId;\r
- ImageBlock = GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);\r
+ ImageBlock = (UINT8 *) GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);\r
if (ImageBlock == NULL) {\r
return EFI_NOT_FOUND;\r
}\r
// BUGBUG: need to be supported as soon as image tool is designed.\r
//\r
return EFI_UNSUPPORTED;\r
- break;\r
\r
case EFI_HII_IIBT_IMAGE_1BIT_TRANS:\r
case EFI_HII_IIBT_IMAGE_4BIT_TRANS:\r
if (BlockType == EFI_HII_IIBT_IMAGE_1BIT || BlockType == EFI_HII_IIBT_IMAGE_1BIT_TRANS) {\r
Output1bitPixel (\r
Image,\r
- (UINT8 *) (ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8)),\r
+ (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8)),\r
(EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
);\r
} else if (BlockType == EFI_HII_IIBT_IMAGE_4BIT || BlockType == EFI_HII_IIBT_IMAGE_4BIT_TRANS) {\r
Output4bitPixel (\r
Image,\r
- (UINT8 *) (ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8)),\r
+ (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8)),\r
(EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
);\r
} else {\r
Output8bitPixel (\r
Image,\r
- (UINT8 *) (ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8)),\r
+ (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8)),\r
(EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
);\r
}\r
\r
return EFI_SUCCESS;\r
- break;\r
\r
case EFI_HII_IIBT_IMAGE_24BIT_TRANS:\r
Flag = TRUE;\r
(EFI_HII_RGB_PIXEL *) (ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL))\r
);\r
return EFI_SUCCESS;\r
- break;\r
\r
default:\r
return EFI_NOT_FOUND;\r
- break;\r
}\r
}\r
\r
)\r
{\r
HII_DATABASE_PRIVATE_DATA *Private;\r
- LIST_ENTRY *Link;\r
- HII_DATABASE_RECORD *DatabaseRecord;\r
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;\r
HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;\r
UINT8 *ImageBlock;\r
}\r
\r
Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
-\r
- //\r
- // Get the specified package list and image package.\r
- //\r
- PackageListNode = NULL;\r
- for (Link = Private->DatabaseList.ForwardLink;\r
- Link != &Private->DatabaseList;\r
- Link = Link->ForwardLink\r
- ) {\r
- DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
- if (DatabaseRecord->Handle == PackageList) {\r
- PackageListNode = DatabaseRecord->PackageList;\r
- break;\r
- }\r
- }\r
+ PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);\r
if (PackageListNode == NULL) {\r
return EFI_NOT_FOUND;\r
}\r
// Find the image block specified by ImageId\r
//\r
LocalImageId = ImageId;\r
- ImageBlock = GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);\r
+ ImageBlock = (UINT8 *) GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);\r
if (ImageBlock == NULL) {\r
return EFI_NOT_FOUND;\r
}\r
// BUGBUG: need to be supported as soon as image tool is designed.\r
//\r
return EFI_UNSUPPORTED;\r
- break;\r
\r
case EFI_HII_IIBT_IMAGE_1BIT:\r
case EFI_HII_IIBT_IMAGE_1BIT_TRANS:\r
break;\r
default:\r
return EFI_NOT_FOUND;\r
- break;\r
}\r
\r
//\r
BlockSize = ImagePackage->ImageBlockSize + NewBlockSize - OldBlockSize;\r
Block = (UINT8 *) AllocateZeroPool (BlockSize);\r
if (Block == NULL) {\r
- SafeFreePool (NewBlock);\r
+ FreePool (NewBlock);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
BlockPtr = Block;\r
- Part1Size = (UINT32) (ImageBlock - ImagePackage->ImageBlock);\r
+ Part1Size = (UINT32) (ImageBlock - (UINT8 *) ImagePackage->ImageBlock);\r
Part2Size = ImagePackage->ImageBlockSize - Part1Size - OldBlockSize;\r
CopyMem (BlockPtr, ImagePackage->ImageBlock, Part1Size);\r
BlockPtr += Part1Size;\r
BlockPtr += NewBlockSize;\r
CopyMem (BlockPtr, ImageBlock + OldBlockSize, Part2Size);\r
\r
- SafeFreePool (ImagePackage->ImageBlock);\r
- SafeFreePool (NewBlock);\r
- ImagePackage->ImageBlock = Block;\r
+ FreePool (ImagePackage->ImageBlock);\r
+ FreePool (NewBlock);\r
+ ImagePackage->ImageBlock = (EFI_HII_IMAGE_BLOCK *) Block;\r
ImagePackage->ImageBlockSize = BlockSize;\r
ImagePackage->ImagePkgHdr.Header.Length += NewBlockSize - OldBlockSize;\r
PackageListNode->PackageListHdr.PackageLength += NewBlockSize - OldBlockSize;\r
\r
+ //\r
+ // Check whether need to get the contents of HiiDataBase.\r
+ // Only after ReadyToBoot to do the export.\r
+ //\r
+ if (gExportAfterReadyToBoot) {\r
+ HiiGetDatabaseInfo(&Private->HiiDatabase);\r
+ }\r
+\r
return EFI_SUCCESS;\r
\r
}\r
will be allocated to hold the generated image and\r
the pointer updated on exit. It is the caller's\r
responsibility to free this buffer.\r
+ @param BltX Specifies the offset from the left and top edge of\r
+ the output image of the first pixel in the image.\r
@param BltY Specifies the offset from the left and top edge of\r
the output image of the first pixel in the image.\r
\r
UINTN BufferLen;\r
UINTN Width;\r
UINTN Height;\r
- UINTN X;\r
- UINTN Y;\r
+ UINTN Xpos;\r
+ UINTN Ypos;\r
UINTN OffsetY1;\r
UINTN OffsetY2;\r
EFI_FONT_DISPLAY_INFO *FontInfo;\r
UINTN Index;\r
- EFI_CONSOLE_CONTROL_PROTOCOL *Console;\r
\r
if (This == NULL || Image == NULL || Blt == NULL) {\r
return EFI_INVALID_PARAMETER;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
+ FontInfo = NULL;\r
ImageIn = (EFI_IMAGE_INPUT *) Image;\r
\r
//\r
if (Width == ImageIn->Width && Height == ImageIn->Height) {\r
CopyMem (BltBuffer, ImageIn->Bitmap, BufferLen);\r
} else {\r
- for (Y = 0; Y < Height; Y++) {\r
- OffsetY1 = ImageIn->Width * Y;\r
- OffsetY2 = Width * Y;\r
- for (X = 0; X < Width; X++) {\r
- BltBuffer[OffsetY2 + X] = ImageIn->Bitmap[OffsetY1 + X];\r
+ for (Ypos = 0; Ypos < Height; Ypos++) {\r
+ OffsetY1 = ImageIn->Width * Ypos;\r
+ OffsetY2 = Width * Ypos;\r
+ for (Xpos = 0; Xpos < Width; Xpos++) {\r
+ BltBuffer[OffsetY2 + Xpos] = ImageIn->Bitmap[OffsetY1 + Xpos];\r
}\r
}\r
}\r
// Draw the image to existing bitmap or screen depending on flag.\r
//\r
if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {\r
- Status = gBS->LocateProtocol (\r
- &gEfiConsoleControlProtocolGuid,\r
- NULL,\r
- (VOID **) &Console\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
+ //\r
+ // Caller should make sure the current UGA console is grarphic mode.\r
+ //\r
\r
- Console->SetMode (Console, EfiConsoleControlScreenGraphics);\r
//\r
// Write the image directly to the output device specified by Screen.\r
//\r
\r
}\r
\r
- SafeFreePool (BltBuffer);\r
+ FreePool (BltBuffer);\r
return Status;\r
\r
} else {\r
\r
ImageOut = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));\r
if (ImageOut == NULL) {\r
- SafeFreePool (BltBuffer);\r
+ FreePool (BltBuffer);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
ImageOut->Width = (UINT16) Width;\r
//\r
Status = GetSystemFont (Private, &FontInfo, NULL);\r
if (EFI_ERROR (Status)) {\r
- SafeFreePool (BltBuffer);\r
- SafeFreePool (ImageOut);\r
+ FreePool (BltBuffer);\r
+ FreePool (ImageOut);\r
return Status;\r
}\r
+ ASSERT (FontInfo != NULL);\r
for (Index = 0; Index < Width * Height; Index++) {\r
BltBuffer[Index] = FontInfo->BackgroundColor;\r
}\r
- SafeFreePool (FontInfo);\r
+ FreePool (FontInfo);\r
\r
//\r
// Draw the incoming image to the new created image.\r
allocated to hold the generated image and the\r
pointer updated on exit. It is the caller's\r
responsibility to free this buffer.\r
+ @param BltX Specifies the offset from the left and top edge of\r
+ the output image of the first pixel in the image.\r
@param BltY Specifies the offset from the left and top edge of\r
the output image of the first pixel in the image.\r
\r
// Draw this image.\r
//\r
Status = HiiDrawImage (This, Flags, &Image, Blt, BltX, BltY);\r
- SafeFreePool (Image.Bitmap);\r
+ if (Image.Bitmap != NULL) {\r
+ FreePool (Image.Bitmap);\r
+ }\r
return Status;\r
}\r
\r
-#endif\r
-\r