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

/** @file\r
\r
Copyright (c) 2007, Intel Corporation\r
All rights reserved. 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
\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
  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
\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
\r
  Returns:\r
    The image block address when input ImageId is not zero; otherwise return NULL.\r
\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
      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
          ASSERT (*ImageId != ImageIdCurrent);\r
          ImageBlock = ImageBlockHdr;\r
          ImageIdCurrent = 1;\r
          continue;\r
        }\r
\r
        return ImageBlock;\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 (((EFI_HII_IMAGE_BLOCK *) ImageBlock)->BlockType) {\r
    case EFI_HII_IIBT_EXT1:\r
      Length8 = *(ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT8));\r
      ImageBlock += Length8;\r
      ImageIdCurrent++;\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
      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
      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
      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
      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
      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
      ImageIdCurrent++;\r
      break;\r
\r
    case EFI_HII_IIBT_DUPLICATE:\r
      ImageBlock += 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
      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
      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
      break;\r
\r
    default:\r
      //\r
      // Unknown image blocks can not be skipped, processing halts.\r
      //\r
      ASSERT (FALSE);\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 ImageBlock;\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
  @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
  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
  @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
  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
  @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
STATIC\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                             X;\r
  UINT16                             Y;\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
  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
  CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
  PaletteSize += sizeof (UINT16);\r
  Palette = AllocateZeroPool (PaletteSize);\r
  ASSERT (Palette != NULL);\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
\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
    //\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 (Index = 0; Index < 8; Index++) {\r
        if ((Byte & (1 << Index)) != 0) {\r
          BitMapPtr[Y * Image->Width + X * 8 + (8 - Index - 1)] = PaletteValue[1];\r
        } else {\r
          BitMapPtr[Y * Image->Width + X * 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 + X);\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
        } else {\r
          BitMapPtr[Y * Image->Width + X * 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
  @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
                                 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 UINT8                           *Data,\r
  IN EFI_HII_IMAGE_PALETTE_INFO      *PaletteInfo\r
  )\r
{\r
  UINT16                             X;\r
  UINT16                             Y;\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
  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
  CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
  PaletteSize += sizeof (UINT16);\r
  Palette = AllocateZeroPool (PaletteSize);\r
  ASSERT (Palette != NULL);\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
\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
    //\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
    }\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
    }\r
  }\r
}\r
\r
\r
/**\r
  Output pixels in "8 bit per pixel" format to an image.\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
                                 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 UINT8                           *Data,\r
  IN EFI_HII_IMAGE_PALETTE_INFO      *PaletteInfo\r
  )\r
{\r
  UINT16                             X;\r
  UINT16                             Y;\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
  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
  CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));\r
  PaletteSize += sizeof (UINT16);\r
  Palette = AllocateZeroPool (PaletteSize);\r
  ASSERT (Palette != NULL);\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
\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
    //\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
    }\r
  }\r
\r
}\r
\r
\r
/**\r
  Output pixels in "24 bit per pixel" format to an image.\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
  UINTN                              OffsetY;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *BitMapPtr;\r
\r
  ASSERT (Image != NULL && Data != NULL);\r
\r
  BitMapPtr = Image->Bitmap;\r
\r
  for (Y = 0; Y < Image->Height; Y++) {\r
    OffsetY = BITMAP_LEN_8_BIT (Image->Width, Y);\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
  @param  BltBuffer              Buffer points to bitmap data of incoming 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
STATIC\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                              X;\r
  UINTN                              Y;\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 (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
      if (Transparent) {\r
        if (CompareMem (&SrcPixel, &ZeroPixel, 3) != 0) {\r
          ImageOut->Image.Bitmap[OffsetY2 + BltX + X] = SrcPixel;\r
        }\r
      } else {\r
        ImageOut->Image.Bitmap[OffsetY2 + BltX + X] = SrcPixel;\r
      }\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\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
  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
  UINTN                               BlockSize;\r
  UINT8                               *NewBlock;\r
  UINT8                               *NewBlockPtr;\r
  UINTN                               NewBlockSize;\r
  EFI_IMAGE_INPUT                     *ImageIn;\r
\r
  if (This == NULL || ImageId == NULL || Image == NULL || PackageList == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (!IsHiiHandleValid (PackageList)) {\r
    return EFI_NOT_FOUND;\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
  if (PackageListNode == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  ImageIn = (EFI_IMAGE_INPUT *) Image;\r
\r
  NewBlockSize = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +\r
                 BITMAP_LEN_24_BIT (ImageIn->Width, ImageIn->Height);\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
    BlockSize  = ImagePackage->ImageBlockSize + NewBlockSize;\r
    ImageBlock = (UINT8 *) AllocateZeroPool (BlockSize);\r
    if (ImageBlock == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // Copy the original content.\r
    //\r
    CopyMem (\r
      ImageBlock,\r
      ImagePackage->ImageBlock,\r
      ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)\r
      );\r
    SafeFreePool (ImagePackage->ImageBlock);\r
    ImagePackage->ImageBlock = 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
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    NewBlockPtr = NewBlock;\r
\r
    //\r
    // Update the length record.\r
    //\r
    ImagePackage->ImageBlockSize = (UINT32) BlockSize;\r
    ImagePackage->ImagePkgHdr.Header.Length += (UINT32) NewBlockSize;\r
    PackageListNode->PackageListHdr.PackageLength += (UINT32) NewBlockSize;\r
\r
  } else {\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
      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
    BlockSize    = sizeof (EFI_HII_IIBT_END_BLOCK) + NewBlockSize;\r
    //\r
    // Fill in image package header.\r
    //\r
    ImagePackage->ImagePkgHdr.Header.Length     = (UINT32) BlockSize + sizeof (EFI_HII_IMAGE_PACKAGE_HDR);\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 = (UINT32) BlockSize;\r
    ImagePackage->ImageBlock = (UINT8 *) AllocateZeroPool (BlockSize);\r
    if (ImagePackage->ImageBlock == NULL) {\r
      SafeFreePool (ImagePackage);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    ImageBlock = 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
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    NewBlockPtr = NewBlock;\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 (ImageIn->Flags == EFI_IMAGE_TRANSPARENT) {\r
    *NewBlock = EFI_HII_IIBT_IMAGE_24BIT_TRANS;\r
  } else {\r
    *NewBlock = EFI_HII_IIBT_IMAGE_24BIT;\r
  }\r
  NewBlock++;\r
  CopyMem (NewBlock, &ImageIn->Width, sizeof (UINT16));\r
  NewBlock += sizeof (UINT16);\r
  CopyMem (NewBlock, &ImageIn->Height, sizeof (UINT16));\r
  NewBlock += sizeof (UINT16);\r
  CopyGopToRgbPixel ((EFI_HII_RGB_PIXEL *) NewBlock, ImageIn->Bitmap, ImageIn->Width * ImageIn->Height);\r
\r
  CopyMem (ImageBlock, NewBlockPtr, NewBlockSize);\r
  SafeFreePool (NewBlockPtr);\r
\r
  //\r
  // Append the block end\r
  //\r
  ImageBlock += NewBlockSize;\r
  ((EFI_HII_IIBT_END_BLOCK *) (ImageBlock))->Header.BlockType = EFI_HII_IIBT_END;\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  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