[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / Image.c

/** @file\r
Implementation for EFI_HII_IMAGE_PROTOCOL.\r
\r
\r
Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
\r
#include "HiiDatabase.h"\r
\r
#define MAX_UINT24    0xFFFFFF\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
  This is a internal function.\r
\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
  @return The image block address when input ImageId is not zero; otherwise return NULL.\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
  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 (CurrentImageBlock->BlockType == EFI_HII_IIBT_DUPLICATE) {\r
          *ImageId = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_DUPLICATE_BLOCK *) CurrentImageBlock)->ImageId);\r
          ASSERT (*ImageId != ImageIdCurrent);\r
          ASSERT (*ImageId != 0);\r
          CurrentImageBlock = ImageBlocks;\r
          ImageIdCurrent = 1;\r
          continue;\r
        }\r
\r
        return CurrentImageBlock;\r
      }\r
      if (*ImageId < ImageIdCurrent) {\r
        //\r
        // Can not find the specified image block in this image.\r
        //\r
        return NULL;\r
      }\r
    }\r
    switch (CurrentImageBlock->BlockType) {\r
    case EFI_HII_IIBT_EXT1:\r
      Length = ((EFI_HII_IIBT_EXT1_BLOCK *) CurrentImageBlock)->Length;\r
      break;\r
    case EFI_HII_IIBT_EXT2:\r
      Length = ReadUnaligned16 (&((EFI_HII_IIBT_EXT2_BLOCK *) CurrentImageBlock)->Length);\r
      break;\r
    case EFI_HII_IIBT_EXT4:\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
      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
      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
      Length = sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +\r
               BITMAP_LEN_8_BIT (\r
                 (UINT32) 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
      Length = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +\r
               BITMAP_LEN_24_BIT (\r
                 (UINT32) 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
      Length = sizeof (EFI_HII_IIBT_DUPLICATE_BLOCK);\r
      ImageIdCurrent++;\r
      break;\r
\r
    case EFI_HII_IIBT_IMAGE_JPEG:\r
      Length = OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Data) + ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size);\r
      ImageIdCurrent++;\r
      break;\r
\r
    case EFI_HII_IIBT_IMAGE_PNG:\r
      Length = OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Data) + ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Size);\r
      ImageIdCurrent++;\r
      break;\r
\r
    case EFI_HII_IIBT_SKIP1:\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
      Length = sizeof (EFI_HII_IIBT_SKIP2_BLOCK);\r
      ImageIdCurrent += ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_SKIP2_BLOCK *) CurrentImageBlock)->SkipCount);\r
      break;\r
\r
    default:\r
      //\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
  // When ImageId is zero, return the imageid of last image block: EFI_HII_IIBT_END_BLOCK.\r
  //\r
  if (*ImageId == 0) {\r
    *ImageId = ImageIdCurrent;\r
    return CurrentImageBlock;\r
  }\r
\r
  return NULL;\r
}\r
\r
\r
\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
VOID\r
CopyGopToRgbPixel (\r
  OUT EFI_HII_RGB_PIXEL              *BitMapOut,\r
  IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BitMapIn,\r
  IN  UINTN                          PixelNum\r
  )\r
{\r
  UINTN Index;\r
\r
  ASSERT (BitMapOut != NULL && BitMapIn != NULL);\r
\r
  for (Index = 0; Index < PixelNum; Index++) {\r
    CopyMem (BitMapOut + Index, BitMapIn + Index, sizeof (EFI_HII_RGB_PIXEL));\r
  }\r
}\r
\r
\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
VOID\r
CopyRgbToGopPixel (\r
  OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BitMapOut,\r
  IN  EFI_HII_RGB_PIXEL              *BitMapIn,\r
  IN  UINTN                          PixelNum\r
  )\r
{\r
  UINTN Index;\r
\r
  ASSERT (BitMapOut != NULL && BitMapIn != NULL);\r
\r
  for (Index = 0; Index < PixelNum; Index++) {\r
    CopyMem (BitMapOut + Index, BitMapIn + Index, sizeof (EFI_HII_RGB_PIXEL));\r
  }\r
}\r
\r
\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
                                 pixels. First entry corresponds to color 0 and\r
                                 second one to color 1.\r
\r
\r
**/\r
VOID\r
Output1bitPixel (\r
  IN OUT EFI_IMAGE_INPUT             *Image,\r
  IN UINT8                           *Data,\r
  IN EFI_HII_IMAGE_PALETTE_INFO      *PaletteInfo\r
  )\r
{\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
  UINTN                              PaletteSize;\r
  UINT8                              Byte;\r
\r
  ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);\r
\r
  BitMapPtr = Image->Bitmap;\r
\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
  FreePool (Palette);\r
\r
  //\r
  // Convert the pixel from one bit to corresponding color.\r
  //\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 (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[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[1];\r
        } else {\r
          BitMapPtr[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[0];\r
        }\r
      }\r
    }\r
\r
    if (Image->Width % 8 != 0) {\r
      //\r
      // Padding bits in this byte should be ignored.\r
      //\r
      Byte = *(Data + OffsetY + Xpos);\r
      for (Index = 0; Index < Image->Width % 8; Index++) {\r
        if ((Byte & (1 << (8 - Index - 1))) != 0) {\r
          BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[1];\r
        } else {\r
          BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[0];\r
        }\r
      }\r
    }\r
  }\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[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
VOID\r
Output4bitPixel (\r
  IN OUT EFI_IMAGE_INPUT             *Image,\r
  IN UINT8                           *Data,\r
  IN EFI_HII_IMAGE_PALETTE_INFO      *PaletteInfo\r
  )\r
{\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
  UINTN                              PaletteSize;\r
  UINT16                             PaletteNum;\r
  UINT8                              Byte;\r
\r
  ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);\r
\r
  BitMapPtr = Image->Bitmap;\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, MIN (PaletteNum, ARRAY_SIZE (PaletteValue)));\r
  FreePool (Palette);\r
\r
  //\r
  // Convert the pixel from 4 bit to corresponding color.\r
  //\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 (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 + Xpos);\r
      BitMapPtr[Ypos * Image->Width + Xpos * 2]     = PaletteValue[Byte >> 4];\r
    }\r
  }\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[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
VOID\r
Output8bitPixel (\r
  IN OUT EFI_IMAGE_INPUT             *Image,\r
  IN UINT8                           *Data,\r
  IN EFI_HII_IMAGE_PALETTE_INFO      *PaletteInfo\r
  )\r
{\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
  UINTN                              PaletteSize;\r
  UINT16                             PaletteNum;\r
  UINT8                              Byte;\r
\r
  ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);\r
\r
  BitMapPtr = Image->Bitmap;\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, MIN (PaletteNum, ARRAY_SIZE (PaletteValue)));\r
  FreePool (Palette);\r
\r
  //\r
  // Convert the pixel from 8 bits to corresponding color.\r
  //\r
  for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
    OffsetY = BITMAP_LEN_8_BIT ((UINT32) Image->Width, Ypos);\r
    //\r
    // All bits are meaningful since the bitmap is 8 bits per pixel.\r
    //\r
    for (Xpos = 0; Xpos < Image->Width; Xpos++) {\r
      Byte = *(Data + OffsetY + Xpos);\r
      BitMapPtr[OffsetY + Xpos] = PaletteValue[Byte];\r
    }\r
  }\r
\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
VOID\r
Output24bitPixel (\r
  IN OUT EFI_IMAGE_INPUT             *Image,\r
  IN EFI_HII_RGB_PIXEL               *Data\r
  )\r
{\r
  UINT16                             Ypos;\r
  UINTN                              OffsetY;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *BitMapPtr;\r
\r
  ASSERT (Image != NULL && Data != NULL);\r
\r
  BitMapPtr = Image->Bitmap;\r
\r
  for (Ypos = 0; Ypos < Image->Height; Ypos++) {\r
    OffsetY = BITMAP_LEN_8_BIT ((UINT32) Image->Width, Ypos);\r
    CopyRgbToGopPixel (&BitMapPtr[OffsetY], &Data[OffsetY], Image->Width);\r
  }\r
\r
}\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
  @param  Height                 Height of the incoming image, in pixels.\r
  @param  Transparent            If TRUE, all "off" pixels in the image will be\r
                                 drawn using the pixel value from blt and all other\r
                                 pixels will be copied.\r
  @param  Blt                    Buffer points to bitmap data of output image.\r
\r
  @retval EFI_SUCCESS            The image was successfully converted.\r
  @retval EFI_INVALID_PARAMETER  Any incoming parameter is invalid.\r
\r
**/\r
EFI_STATUS\r
ImageToBlt (\r
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL   *BltBuffer,\r
  IN UINTN                           BltX,\r
  IN UINTN                           BltY,\r
  IN UINTN                           Width,\r
  IN UINTN                           Height,\r
  IN BOOLEAN                         Transparent,\r
  IN OUT EFI_IMAGE_OUTPUT            **Blt\r
  )\r
{\r
  EFI_IMAGE_OUTPUT                   *ImageOut;\r
  UINTN                              Xpos;\r
  UINTN                              Ypos;\r
  UINTN                              OffsetY1; // src buffer\r
  UINTN                              OffsetY2; // dest buffer\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      SrcPixel;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      ZeroPixel;\r
\r
  if (BltBuffer == NULL || Blt == NULL || *Blt == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ImageOut = *Blt;\r
\r
  if (Width + BltX > ImageOut->Width) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if (Height + BltY > ImageOut->Height) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ZeroMem (&ZeroPixel, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));\r
\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 + Xpos] = SrcPixel;\r
        }\r
      } else {\r
        ImageOut->Image.Bitmap[OffsetY2 + BltX + Xpos] = SrcPixel;\r
      }\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
  a new image identifier (ImageId).\r
\r
  @param  This                   A pointer to the EFI_HII_IMAGE_PROTOCOL instance.\r
  @param  PackageList            Handle of the package list where this image will\r
                                 be added.\r
  @param  ImageId                On return, contains the new image id, which is\r
                                 unique within PackageList.\r
  @param  Image                  Points to the image.\r
\r
  @retval EFI_SUCCESS            The new image was added successfully.\r
  @retval EFI_NOT_FOUND          The specified PackageList could not be found in\r
                                 database.\r
  @retval EFI_OUT_OF_RESOURCES   Could not add the image due to lack of resources.\r
  @retval EFI_INVALID_PARAMETER  Image is NULL or ImageId is NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiNewImage (\r
  IN  CONST EFI_HII_IMAGE_PROTOCOL   *This,\r
  IN  EFI_HII_HANDLE                 PackageList,\r
  OUT EFI_IMAGE_ID                   *ImageId,\r
  IN  CONST EFI_IMAGE_INPUT          *Image\r
  )\r
{\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  HII_DATABASE_PACKAGE_LIST_INSTANCE  *PackageListNode;\r
  HII_IMAGE_PACKAGE_INSTANCE          *ImagePackage;\r
  EFI_HII_IMAGE_BLOCK                 *ImageBlocks;\r
  UINT32                              NewBlockSize;\r
\r
  if (This == NULL || ImageId == NULL || Image == NULL || Image->Bitmap == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);\r
  if (PackageListNode == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  EfiAcquireLock (&mHiiDatabaseLock);\r
\r
  //\r
  // Calcuate the size of new image.\r
  // Make sure the size doesn't overflow UINT32.\r
  // Note: 24Bit BMP occpuies 3 bytes per pixel.\r
  //\r
  NewBlockSize = (UINT32)Image->Width * Image->Height;\r
  if (NewBlockSize > (MAX_UINT32 - (sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL))) / 3) {\r
    EfiReleaseLock (&mHiiDatabaseLock);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  NewBlockSize = NewBlockSize * 3 + (sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL));\r
\r
  //\r
  // Get the image package in the package list,\r
  // or create a new image package if image package does not exist.\r
  //\r
  if (PackageListNode->ImagePkg != NULL) {\r
    ImagePackage = PackageListNode->ImagePkg;\r
\r
    //\r
    // Output the image id of the incoming image being inserted, which is the\r
    // image id of the EFI_HII_IIBT_END block of old image package.\r
    //\r
    *ImageId = 0;\r
    GetImageIdOrAddress (ImagePackage->ImageBlock, ImageId);\r
\r
    //\r
    // Update the package's image block by appending the new block to the end.\r
    //\r
\r
    //\r
    // Make sure the final package length doesn't overflow.\r
    // Length of the package header is represented using 24 bits. So MAX length is MAX_UINT24.\r
    //\r
    if (NewBlockSize > MAX_UINT24 - ImagePackage->ImagePkgHdr.Header.Length) {\r
      EfiReleaseLock (&mHiiDatabaseLock);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // Because ImagePackage->ImageBlockSize < ImagePackage->ImagePkgHdr.Header.Length,\r
    // So (ImagePackage->ImageBlockSize + NewBlockSize) <= MAX_UINT24\r
    //\r
    ImageBlocks = AllocatePool (ImagePackage->ImageBlockSize + NewBlockSize);\r
    if (ImageBlocks == NULL) {\r
      EfiReleaseLock (&mHiiDatabaseLock);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // Copy the original content.\r
    //\r
    CopyMem (\r
      ImageBlocks,\r
      ImagePackage->ImageBlock,\r
      ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)\r
      );\r
    FreePool (ImagePackage->ImageBlock);\r
    ImagePackage->ImageBlock = ImageBlocks;\r
\r
    //\r
    // Point to the very last block.\r
    //\r
    ImageBlocks = (EFI_HII_IMAGE_BLOCK *) (\r
                    (UINT8 *) ImageBlocks + ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)\r
                    );\r
    //\r
    // Update the length record.\r
    //\r
    ImagePackage->ImageBlockSize                  += NewBlockSize;\r
    ImagePackage->ImagePkgHdr.Header.Length       += NewBlockSize;\r
    PackageListNode->PackageListHdr.PackageLength += NewBlockSize;\r
\r
  } else {\r
    //\r
    // Make sure the final package length doesn't overflow.\r
    // Length of the package header is represented using 24 bits. So MAX length is MAX_UINT24.\r
    //\r
    if (NewBlockSize > MAX_UINT24 - (sizeof (EFI_HII_IMAGE_PACKAGE_HDR) + sizeof (EFI_HII_IIBT_END_BLOCK))) {\r
      EfiReleaseLock (&mHiiDatabaseLock);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // The specified package list does not contain image package.\r
    // Create one to add this image block.\r
    //\r
    ImagePackage = (HII_IMAGE_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_IMAGE_PACKAGE_INSTANCE));\r
    if (ImagePackage == NULL) {\r
      EfiReleaseLock (&mHiiDatabaseLock);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // Output the image id of the incoming image being inserted, which is the\r
    // first image block so that id is initially to one.\r
    //\r
    *ImageId = 1;\r
    //\r
    // Fill in image package header.\r
    //\r
    ImagePackage->ImagePkgHdr.Header.Length     = sizeof (EFI_HII_IMAGE_PACKAGE_HDR) + NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK);\r
    ImagePackage->ImagePkgHdr.Header.Type       = EFI_HII_PACKAGE_IMAGES;\r
    ImagePackage->ImagePkgHdr.ImageInfoOffset   = sizeof (EFI_HII_IMAGE_PACKAGE_HDR);\r
    ImagePackage->ImagePkgHdr.PaletteInfoOffset = 0;\r
\r
    //\r
    // Fill in palette info.\r
    //\r
    ImagePackage->PaletteBlock    = NULL;\r
    ImagePackage->PaletteInfoSize = 0;\r
\r
    //\r
    // Fill in image blocks.\r
    //\r
    ImagePackage->ImageBlockSize = NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK);\r
    ImagePackage->ImageBlock = AllocateZeroPool (NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK));\r
    if (ImagePackage->ImageBlock == NULL) {\r
      FreePool (ImagePackage);\r
      EfiReleaseLock (&mHiiDatabaseLock);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    ImageBlocks = ImagePackage->ImageBlock;\r
\r
    //\r
    // Insert this image package.\r
    //\r
    PackageListNode->ImagePkg = ImagePackage;\r
    PackageListNode->PackageListHdr.PackageLength += ImagePackage->ImagePkgHdr.Header.Length;\r
  }\r
\r
  //\r
  // Append the new block here\r
  //\r
  if (Image->Flags == EFI_IMAGE_TRANSPARENT) {\r
    ImageBlocks->BlockType = EFI_HII_IIBT_IMAGE_24BIT_TRANS;\r
  } else {\r
    ImageBlocks->BlockType = EFI_HII_IIBT_IMAGE_24BIT;\r
  }\r
  WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Width, Image->Width);\r
  WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Height, Image->Height);\r
  CopyGopToRgbPixel (((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Bitmap, Image->Bitmap, (UINT32) Image->Width * Image->Height);\r
\r
  //\r
  // Append the block end\r
  //\r
  ImageBlocks = (EFI_HII_IMAGE_BLOCK *) ((UINT8 *) ImageBlocks + NewBlockSize);\r
  ImageBlocks->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
  EfiReleaseLock (&mHiiDatabaseLock);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  This function retrieves the image specified by ImageId which is associated with\r
  the specified PackageList and copies it into the buffer specified by Image.\r
\r
  @param  Database               A pointer to the database list header.\r
  @param  PackageList            Handle of the package list where this image will\r
                                 be searched.\r
  @param  ImageId                The image's id,, which is unique within\r
                                 PackageList.\r
  @param  Image                  Points to the image.\r
  @param  BitmapOnly             TRUE to only return the bitmap type image.\r
                                 FALSE to locate image decoder instance to decode image.\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
                                 database. The specified PackageList is not in the database.\r
  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to\r
                                 hold the image.\r
  @retval EFI_INVALID_PARAMETER  The Image or ImageSize was NULL.\r
  @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there was not\r
                                 enough memory.\r
**/\r
EFI_STATUS\r
IGetImage (\r
  IN  LIST_ENTRY                     *Database,\r
  IN  EFI_HII_HANDLE                 PackageList,\r
  IN  EFI_IMAGE_ID                   ImageId,\r
  OUT EFI_IMAGE_INPUT                *Image,\r
  IN  BOOLEAN                        BitmapOnly\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  HII_DATABASE_PACKAGE_LIST_INSTANCE  *PackageListNode;\r
  HII_IMAGE_PACKAGE_INSTANCE          *ImagePackage;\r
  EFI_HII_IMAGE_BLOCK                 *CurrentImageBlock;\r
  EFI_HII_IIBT_IMAGE_1BIT_BLOCK       Iibt1bit;\r
  UINT16                              Width;\r
  UINT16                              Height;\r
  UINTN                               ImageLength;\r
  UINT8                               *PaletteInfo;\r
  UINT8                               PaletteIndex;\r
  UINT16                              PaletteSize;\r
  EFI_HII_IMAGE_DECODER_PROTOCOL      *Decoder;\r
  EFI_IMAGE_OUTPUT                    *ImageOut;\r
\r
  if (Image == NULL || ImageId == 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  PackageListNode = LocatePackageList (Database, PackageList);\r
  if (PackageListNode == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
  ImagePackage = PackageListNode->ImagePkg;\r
  if (ImagePackage == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Find the image block specified by ImageId\r
  //\r
  CurrentImageBlock = GetImageIdOrAddress (ImagePackage->ImageBlock, &ImageId);\r
  if (CurrentImageBlock == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  Image->Flags = 0;\r
  switch (CurrentImageBlock->BlockType) {\r
  case EFI_HII_IIBT_IMAGE_JPEG:\r
  case EFI_HII_IIBT_IMAGE_PNG:\r
    if (BitmapOnly) {\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    ImageOut = NULL;\r
    Decoder = LocateHiiImageDecoder (CurrentImageBlock->BlockType);\r
    if (Decoder == NULL) {\r
      return EFI_UNSUPPORTED;\r
    }\r
    //\r
    // Use the common block code since the definition of two structures is the same.\r
    //\r
    ASSERT (OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Data) == OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Data));\r
    ASSERT (sizeof (((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Data) ==\r
            sizeof (((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Data));\r
    ASSERT (OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Size) == OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Size));\r
    ASSERT (sizeof (((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size) ==\r
            sizeof (((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Size));\r
    Status = Decoder->DecodeImage (\r
      Decoder,\r
      ((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Data,\r
      ((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size,\r
      &ImageOut,\r
      FALSE\r
    );\r
\r
    //\r
    // Spec requires to use the first capable image decoder instance.\r
    // The first image decoder instance may fail to decode the image.\r
    //\r
    if (!EFI_ERROR (Status)) {\r
      Image->Bitmap = ImageOut->Image.Bitmap;\r
      Image->Height = ImageOut->Height;\r
      Image->Width = ImageOut->Width;\r
      FreePool (ImageOut);\r
    }\r
    return Status;\r
\r
  case EFI_HII_IIBT_IMAGE_1BIT_TRANS:\r
  case EFI_HII_IIBT_IMAGE_4BIT_TRANS:\r
  case EFI_HII_IIBT_IMAGE_8BIT_TRANS:\r
    Image->Flags = EFI_IMAGE_TRANSPARENT;\r
    //\r
    // fall through\r
    //\r
  case EFI_HII_IIBT_IMAGE_1BIT:\r
  case EFI_HII_IIBT_IMAGE_4BIT:\r
  case EFI_HII_IIBT_IMAGE_8BIT:\r
    //\r
    // Use the common block code since the definition of these structures is the same.\r
    //\r
    CopyMem (&Iibt1bit, CurrentImageBlock, sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK));\r
    ImageLength = (UINTN) Iibt1bit.Bitmap.Width * Iibt1bit.Bitmap.Height;\r
    if (ImageLength > MAX_UINTN / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    ImageLength  *= sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);\r
    Image->Bitmap = AllocateZeroPool (ImageLength);\r
    if (Image->Bitmap == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Image->Width  = Iibt1bit.Bitmap.Width;\r
    Image->Height = Iibt1bit.Bitmap.Height;\r
\r
    PaletteInfo = ImagePackage->PaletteBlock + sizeof (EFI_HII_IMAGE_PALETTE_INFO_HEADER);\r
    for (PaletteIndex = 1; PaletteIndex < Iibt1bit.PaletteIndex; PaletteIndex++) {\r
      CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
      PaletteInfo += PaletteSize + sizeof (UINT16);\r
    }\r
    ASSERT (PaletteIndex == Iibt1bit.PaletteIndex);\r
\r
    //\r
    // Output bitmap data\r
    //\r
    if (CurrentImageBlock->BlockType == EFI_HII_IIBT_IMAGE_1BIT ||\r
        CurrentImageBlock->BlockType == EFI_HII_IIBT_IMAGE_1BIT_TRANS) {\r
      Output1bitPixel (\r
        Image,\r
        ((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Data,\r
        (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
        );\r
    } else if (CurrentImageBlock->BlockType == EFI_HII_IIBT_IMAGE_4BIT ||\r
               CurrentImageBlock->BlockType == EFI_HII_IIBT_IMAGE_4BIT_TRANS) {\r
      Output4bitPixel (\r
        Image,\r
        ((EFI_HII_IIBT_IMAGE_4BIT_BLOCK *) CurrentImageBlock)->Bitmap.Data,\r
        (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
        );\r
    } else {\r
      Output8bitPixel (\r
        Image,\r
        ((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Data,\r
        (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo\r
        );\r
    }\r
\r
    return EFI_SUCCESS;\r
\r
  case EFI_HII_IIBT_IMAGE_24BIT_TRANS:\r
    Image->Flags = EFI_IMAGE_TRANSPARENT;\r
    //\r
    // fall through\r
    //\r
  case EFI_HII_IIBT_IMAGE_24BIT:\r
    Width  = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width);\r
    Height = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height);\r
    ImageLength = (UINTN)Width * Height;\r
    if (ImageLength > MAX_UINTN / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    ImageLength  *= sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);\r
    Image->Bitmap = AllocateZeroPool (ImageLength);\r
    if (Image->Bitmap == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Image->Width  = Width;\r
    Image->Height = Height;\r
\r
    //\r
    // Output the bitmap data directly.\r
    //\r
    Output24bitPixel (\r
      Image,\r
      ((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Bitmap\r
      );\r
    return EFI_SUCCESS;\r
\r
  default:\r
    return EFI_NOT_FOUND;\r
  }\r
}\r
\r
/**\r
  This function retrieves the image specified by ImageId which is associated with\r
  the specified PackageList and copies it into the buffer specified by Image.\r
\r
  @param  This                   A pointer to the EFI_HII_IMAGE_PROTOCOL instance.\r
  @param  PackageList            Handle of the package list where this image will\r
                                 be searched.\r
  @param  ImageId                The image's id,, which is unique within\r
                                 PackageList.\r
  @param  Image                  Points to the image.\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
                                                database. The specified PackageList is not in the database.\r
  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to\r
                                 hold the image.\r
  @retval EFI_INVALID_PARAMETER  The Image or ImageSize was NULL.\r
  @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there was not\r
                                 enough memory.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiGetImage (\r
  IN  CONST EFI_HII_IMAGE_PROTOCOL   *This,\r
  IN  EFI_HII_HANDLE                 PackageList,\r
  IN  EFI_IMAGE_ID                   ImageId,\r
  OUT EFI_IMAGE_INPUT                *Image\r
  )\r
{\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  return IGetImage (&Private->DatabaseList, PackageList, ImageId, Image, TRUE);\r
}\r
\r
\r
/**\r
  This function updates the image specified by ImageId in the specified PackageListHandle to\r
  the image specified by Image.\r
\r
  @param  This                   A pointer to the EFI_HII_IMAGE_PROTOCOL instance.\r
  @param  PackageList            The package list containing the images.\r
  @param  ImageId                The image's id,, which is unique within\r
                                 PackageList.\r
  @param  Image                  Points to the image.\r
\r
  @retval EFI_SUCCESS            The new image was updated successfully.\r
  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the\r
                                                database. The specified PackageList is not in the database.\r
  @retval EFI_INVALID_PARAMETER  The Image was NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiSetImage (\r
  IN CONST EFI_HII_IMAGE_PROTOCOL    *This,\r
  IN EFI_HII_HANDLE                  PackageList,\r
  IN EFI_IMAGE_ID                    ImageId,\r
  IN CONST EFI_IMAGE_INPUT           *Image\r
  )\r
{\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  HII_DATABASE_PACKAGE_LIST_INSTANCE  *PackageListNode;\r
  HII_IMAGE_PACKAGE_INSTANCE          *ImagePackage;\r
  EFI_HII_IMAGE_BLOCK                 *CurrentImageBlock;\r
  EFI_HII_IMAGE_BLOCK                 *ImageBlocks;\r
  EFI_HII_IMAGE_BLOCK                 *NewImageBlock;\r
  UINT32                              NewBlockSize;\r
  UINT32                              OldBlockSize;\r
  UINT32                               Part1Size;\r
  UINT32                               Part2Size;\r
\r
  if (This == NULL || Image == NULL || ImageId == 0 || Image->Bitmap == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);\r
  if (PackageListNode == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
  ImagePackage = PackageListNode->ImagePkg;\r
  if (ImagePackage == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Find the image block specified by ImageId\r
  //\r
  CurrentImageBlock = GetImageIdOrAddress (ImagePackage->ImageBlock, &ImageId);\r
  if (CurrentImageBlock == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  EfiAcquireLock (&mHiiDatabaseLock);\r
\r
  //\r
  // Get the size of original image block. Use some common block code here\r
  // since the definition of some structures is the same.\r
  //\r
  switch (CurrentImageBlock->BlockType) {\r
  case EFI_HII_IIBT_IMAGE_JPEG:\r
    OldBlockSize = OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Data) + ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size);\r
    break;\r
  case EFI_HII_IIBT_IMAGE_PNG:\r
    OldBlockSize = OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Data) + ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Size);\r
    break;\r
  case EFI_HII_IIBT_IMAGE_1BIT:\r
  case EFI_HII_IIBT_IMAGE_1BIT_TRANS:\r
    OldBlockSize = 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
    break;\r
  case EFI_HII_IIBT_IMAGE_4BIT:\r
  case EFI_HII_IIBT_IMAGE_4BIT_TRANS:\r
    OldBlockSize = 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
    break;\r
  case EFI_HII_IIBT_IMAGE_8BIT:\r
  case EFI_HII_IIBT_IMAGE_8BIT_TRANS:\r
    OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +\r
                   BITMAP_LEN_8_BIT (\r
                     (UINT32) ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),\r
                     ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)\r
                     );\r
    break;\r
  case EFI_HII_IIBT_IMAGE_24BIT:\r
  case EFI_HII_IIBT_IMAGE_24BIT_TRANS:\r
    OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +\r
                   BITMAP_LEN_24_BIT (\r
                     (UINT32) 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
    break;\r
  default:\r
    EfiReleaseLock (&mHiiDatabaseLock);\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Create the new image block according to input image.\r
  //\r
\r
  //\r
  // Make sure the final package length doesn't overflow.\r
  // Length of the package header is represented using 24 bits. So MAX length is MAX_UINT24.\r
  // 24Bit BMP occpuies 3 bytes per pixel.\r
  //\r
  NewBlockSize = (UINT32)Image->Width * Image->Height;\r
  if (NewBlockSize > (MAX_UINT32 - (sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL))) / 3) {\r
    EfiReleaseLock (&mHiiDatabaseLock);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  NewBlockSize = NewBlockSize * 3 + (sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL));\r
  if ((NewBlockSize > OldBlockSize) &&\r
      (NewBlockSize - OldBlockSize > MAX_UINT24 - ImagePackage->ImagePkgHdr.Header.Length)\r
      ) {\r
    EfiReleaseLock (&mHiiDatabaseLock);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Adjust the image package to remove the original block firstly then add the new block.\r
  //\r
  ImageBlocks = AllocateZeroPool (ImagePackage->ImageBlockSize + NewBlockSize - OldBlockSize);\r
  if (ImageBlocks == NULL) {\r
    EfiReleaseLock (&mHiiDatabaseLock);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Part1Size = (UINT32) ((UINTN) CurrentImageBlock - (UINTN) ImagePackage->ImageBlock);\r
  Part2Size = ImagePackage->ImageBlockSize - Part1Size - OldBlockSize;\r
  CopyMem (ImageBlocks, ImagePackage->ImageBlock, Part1Size);\r
\r
  //\r
  // Set the new image block\r
  //\r
  NewImageBlock = (EFI_HII_IMAGE_BLOCK *) ((UINT8 *) ImageBlocks + Part1Size);\r
  if ((Image->Flags & EFI_IMAGE_TRANSPARENT) == EFI_IMAGE_TRANSPARENT) {\r
    NewImageBlock->BlockType= EFI_HII_IIBT_IMAGE_24BIT_TRANS;\r
  } else {\r
    NewImageBlock->BlockType = EFI_HII_IIBT_IMAGE_24BIT;\r
  }\r
  WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) NewImageBlock)->Bitmap.Width, Image->Width);\r
  WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) NewImageBlock)->Bitmap.Height, Image->Height);\r
  CopyGopToRgbPixel (((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) NewImageBlock)->Bitmap.Bitmap,\r
                       Image->Bitmap, (UINT32) Image->Width * Image->Height);\r
\r
  CopyMem ((UINT8 *) NewImageBlock + NewBlockSize, (UINT8 *) CurrentImageBlock + OldBlockSize, Part2Size);\r
\r
  FreePool (ImagePackage->ImageBlock);\r
  ImagePackage->ImageBlock                       = ImageBlocks;\r
  ImagePackage->ImageBlockSize                  += NewBlockSize - OldBlockSize;\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
  EfiReleaseLock (&mHiiDatabaseLock);\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
/**\r
  This function renders an image to a bitmap or the screen using the specified\r
  color and options. It draws the image on an existing bitmap, allocates a new\r
  bitmap or uses the screen. The images can be clipped.\r
\r
  @param  This                   A pointer to the EFI_HII_IMAGE_PROTOCOL instance.\r
  @param  Flags                  Describes how the image is to be drawn.\r
  @param  Image                  Points to the image to be displayed.\r
  @param  Blt                    If this points to a non-NULL on entry, this points\r
                                 to the image, which is Width pixels wide and\r
                                 Height pixels high.  The image will be drawn onto\r
                                 this image and  EFI_HII_DRAW_FLAG_CLIP is implied.\r
                                 If this points to a  NULL on entry, then a buffer\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
  @retval EFI_SUCCESS            The image was successfully drawn.\r
  @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.\r
  @retval EFI_INVALID_PARAMETER  The Image or Blt was NULL.\r
  @retval EFI_INVALID_PARAMETER  Any combination of Flags is invalid.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiDrawImage (\r
  IN CONST EFI_HII_IMAGE_PROTOCOL    *This,\r
  IN EFI_HII_DRAW_FLAGS              Flags,\r
  IN CONST EFI_IMAGE_INPUT           *Image,\r
  IN OUT EFI_IMAGE_OUTPUT            **Blt,\r
  IN UINTN                           BltX,\r
  IN UINTN                           BltY\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  BOOLEAN                             Transparent;\r
  EFI_IMAGE_OUTPUT                    *ImageOut;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL       *BltBuffer;\r
  UINTN                               BufferLen;\r
  UINT16                              Width;\r
  UINT16                              Height;\r
  UINTN                               Xpos;\r
  UINTN                               Ypos;\r
  UINTN                               OffsetY1;\r
  UINTN                               OffsetY2;\r
  EFI_FONT_DISPLAY_INFO               *FontInfo;\r
  UINTN                               Index;\r
\r
  if (This == NULL || Image == NULL || Blt == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((Flags & EFI_HII_DRAW_FLAG_CLIP) == EFI_HII_DRAW_FLAG_CLIP && *Blt == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_TRANSPARENT) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FontInfo = NULL;\r
\r
  //\r
  // Check whether the image will be drawn transparently or opaquely.\r
  //\r
  Transparent = FALSE;\r
  if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_TRANS) {\r
    Transparent = TRUE;\r
  } else if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_OPAQUE){\r
    Transparent = FALSE;\r
  } else {\r
    //\r
    // Now EFI_HII_DRAW_FLAG_DEFAULT is set, whether image will be drawn depending\r
    // on the image's transparency setting.\r
    //\r
    if ((Image->Flags & EFI_IMAGE_TRANSPARENT) == EFI_IMAGE_TRANSPARENT) {\r
      Transparent = TRUE;\r
    }\r
  }\r
\r
  //\r
  // Image cannot be drawn transparently if Blt points to NULL on entry.\r
  // Currently output to Screen transparently is not supported, either.\r
  //\r
  if (Transparent) {\r
    if (*Blt == NULL) {\r
      return EFI_INVALID_PARAMETER;\r
    } else if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
\r
  //\r
  // When Blt points to a non-NULL on entry, this image will be drawn onto\r
  // this bitmap or screen pointed by "*Blt" and EFI_HII_DRAW_FLAG_CLIP is implied.\r
  // Otherwise a new bitmap will be allocated to hold this image.\r
  //\r
  if (*Blt != NULL) {\r
    //\r
    // Make sure the BltX and BltY is inside the Blt area.\r
    //\r
    if ((BltX >= (*Blt)->Width) || (BltY >= (*Blt)->Height)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // Clip the image by (Width, Height)\r
    //\r
\r
    Width  = Image->Width;\r
    Height = Image->Height;\r
\r
    if (Width > (*Blt)->Width - (UINT16)BltX) {\r
      Width = (*Blt)->Width - (UINT16)BltX;\r
    }\r
    if (Height > (*Blt)->Height - (UINT16)BltY) {\r
      Height = (*Blt)->Height - (UINT16)BltY;\r
    }\r
\r
    //\r
    // Prepare the buffer for the temporary image.\r
    // Make sure the buffer size doesn't overflow UINTN.\r
    //\r
    BufferLen = Width * Height;\r
    if (BufferLen > MAX_UINTN / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    BufferLen *= sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);\r
    BltBuffer  = AllocateZeroPool (BufferLen);\r
    if (BltBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    if (Width == Image->Width && Height == Image->Height) {\r
      CopyMem (BltBuffer, Image->Bitmap, BufferLen);\r
    } else {\r
      for (Ypos = 0; Ypos < Height; Ypos++) {\r
        OffsetY1 = Image->Width * Ypos;\r
        OffsetY2 = Width * Ypos;\r
        for (Xpos = 0; Xpos < Width; Xpos++) {\r
          BltBuffer[OffsetY2 + Xpos] = Image->Bitmap[OffsetY1 + Xpos];\r
        }\r
      }\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
      //\r
      // Caller should make sure the current UGA console is grarphic mode.\r
      //\r
\r
      //\r
      // Write the image directly to the output device specified by Screen.\r
      //\r
      Status = (*Blt)->Image.Screen->Blt (\r
                                       (*Blt)->Image.Screen,\r
                                       BltBuffer,\r
                                       EfiBltBufferToVideo,\r
                                       0,\r
                                       0,\r
                                       BltX,\r
                                       BltY,\r
                                       Width,\r
                                       Height,\r
                                       0\r
                                       );\r
    } else {\r
      //\r
      // Draw the image onto the existing bitmap specified by Bitmap.\r
      //\r
      Status = ImageToBlt (\r
                 BltBuffer,\r
                 BltX,\r
                 BltY,\r
                 Width,\r
                 Height,\r
                 Transparent,\r
                 Blt\r
                 );\r
\r
    }\r
\r
    FreePool (BltBuffer);\r
    return Status;\r
\r
  } else {\r
    //\r
    // Allocate a new bitmap to hold the incoming image.\r
    //\r
\r
    //\r
    // Make sure the final width and height doesn't overflow UINT16.\r
    //\r
    if ((BltX > (UINTN)MAX_UINT16 - Image->Width) || (BltY > (UINTN)MAX_UINT16 - Image->Height)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    Width  = Image->Width  + (UINT16)BltX;\r
    Height = Image->Height + (UINT16)BltY;\r
\r
    //\r
    // Make sure the output image size doesn't overflow UINTN.\r
    //\r
    BufferLen = Width * Height;\r
    if (BufferLen > MAX_UINTN / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    BufferLen *= sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);\r
    BltBuffer  = AllocateZeroPool (BufferLen);\r
    if (BltBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    ImageOut = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));\r
    if (ImageOut == NULL) {\r
      FreePool (BltBuffer);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    ImageOut->Width        = Width;\r
    ImageOut->Height       = Height;\r
    ImageOut->Image.Bitmap = BltBuffer;\r
\r
    //\r
    // BUGBUG: Now all the "blank" pixels are filled with system default background\r
    // color. Not sure if it need to be updated or not.\r
    //\r
    Status = GetSystemFont (Private, &FontInfo, NULL);\r
    if (EFI_ERROR (Status)) {\r
      FreePool (BltBuffer);\r
      FreePool (ImageOut);\r
      return Status;\r
    }\r
    ASSERT (FontInfo != NULL);\r
    for (Index = 0; Index < (UINTN)Width * Height; Index++) {\r
      BltBuffer[Index] = FontInfo->BackgroundColor;\r
    }\r
    FreePool (FontInfo);\r
\r
    //\r
    // Draw the incoming image to the new created image.\r
    //\r
    *Blt = ImageOut;\r
    return ImageToBlt (\r
             Image->Bitmap,\r
             BltX,\r
             BltY,\r
             Image->Width,\r
             Image->Height,\r
             Transparent,\r
             Blt\r
             );\r
\r
  }\r
}\r
\r
\r
/**\r
  This function renders an image to a bitmap or the screen using the specified\r
  color and options. It draws the image on an existing bitmap, allocates a new\r
  bitmap or uses the screen. The images can be clipped.\r
\r
  @param  This                   A pointer to the EFI_HII_IMAGE_PROTOCOL instance.\r
  @param  Flags                  Describes how the image is to be drawn.\r
  @param  PackageList            The package list in the HII database to search for\r
                                 the  specified image.\r
  @param  ImageId                The image's id, which is unique within\r
                                 PackageList.\r
  @param  Blt                    If this points to a non-NULL on entry, this points\r
                                 to the image, which is Width pixels wide and\r
                                 Height pixels high. The image will be drawn onto\r
                                 this image and\r
                                 EFI_HII_DRAW_FLAG_CLIP is implied. If this points\r
                                 to a  NULL on entry, then a buffer will be\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
  @retval EFI_SUCCESS            The image was successfully drawn.\r
  @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.\r
  @retval EFI_INVALID_PARAMETER  The Blt was NULL.\r
  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the database.\r
                           The specified PackageList is not in the database.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiDrawImageId (\r
  IN CONST EFI_HII_IMAGE_PROTOCOL    *This,\r
  IN EFI_HII_DRAW_FLAGS              Flags,\r
  IN EFI_HII_HANDLE                  PackageList,\r
  IN EFI_IMAGE_ID                    ImageId,\r
  IN OUT EFI_IMAGE_OUTPUT            **Blt,\r
  IN UINTN                           BltX,\r
  IN UINTN                           BltY\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  EFI_IMAGE_INPUT                     Image;\r
\r
  //\r
  // Check input parameter.\r
  //\r
  if (This == NULL || Blt == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Get the specified Image.\r
  //\r
  Status = HiiGetImage (This, PackageList, ImageId, &Image);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Draw this image.\r
  //\r
  Status = HiiDrawImage (This, Flags, &Image, Blt, BltX, BltY);\r
  if (Image.Bitmap != NULL) {\r
    FreePool (Image.Bitmap);\r
  }\r
  return Status;\r
}\r
\r