Home | History | Annotate | Download | only in HiiDatabaseDxe
      1 /** @file
      2 Implementation for EFI_HII_IMAGE_EX_PROTOCOL.
      3 
      4 
      5 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
      6 This program and the accompanying materials
      7 are licensed and made available under the terms and conditions of the BSD License
      8 which accompanies this distribution.  The full text of the license may be found at
      9 http://opensource.org/licenses/bsd-license.php
     10 
     11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     13 
     14 **/
     15 
     16 
     17 #include "HiiDatabase.h"
     18 
     19 /**
     20   The prototype of this extension function is the same with EFI_HII_IMAGE_PROTOCOL.NewImage().
     21   This protocol invokes EFI_HII_IMAGE_PROTOCOL.NewImage() implicitly.
     22 
     23   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
     24   @param  PackageList            Handle of the package list where this image will
     25                                  be added.
     26   @param  ImageId                On return, contains the new image id, which is
     27                                  unique within PackageList.
     28   @param  Image                  Points to the image.
     29 
     30   @retval EFI_SUCCESS            The new image was added successfully.
     31   @retval EFI_NOT_FOUND          The PackageList could not be found.
     32   @retval EFI_OUT_OF_RESOURCES   Could not add the image due to lack of resources.
     33   @retval EFI_INVALID_PARAMETER  Image is NULL or ImageId is NULL.
     34 **/
     35 EFI_STATUS
     36 EFIAPI
     37 HiiNewImageEx (
     38   IN  CONST EFI_HII_IMAGE_EX_PROTOCOL *This,
     39   IN  EFI_HII_HANDLE                  PackageList,
     40   OUT EFI_IMAGE_ID                    *ImageId,
     41   IN  CONST EFI_IMAGE_INPUT           *Image
     42   )
     43 {
     44   HII_DATABASE_PRIVATE_DATA           *Private;
     45 
     46   Private = HII_IMAGE_EX_DATABASE_PRIVATE_DATA_FROM_THIS (This);
     47   return HiiNewImage (&Private->HiiImage, PackageList, ImageId, Image);
     48 }
     49 
     50 /**
     51   Return the information about the image, associated with the package list.
     52   The prototype of this extension function is the same with EFI_HII_IMAGE_PROTOCOL.GetImage().
     53 
     54   This function is similar to EFI_HII_IMAGE_PROTOCOL.GetImage().The difference is that
     55   this function will locate all EFI_HII_IMAGE_DECODER_PROTOCOL instances installed in the
     56   system if the decoder of the certain image type is not supported by the
     57   EFI_HII_IMAGE_EX_PROTOCOL. The function will attempt to decode the image to the
     58   EFI_IMAGE_INPUT using the first EFI_HII_IMAGE_DECODER_PROTOCOL instance that
     59   supports the requested image type.
     60 
     61   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
     62   @param  PackageList            The package list in the HII database to search for the
     63                                  specified image.
     64   @param  ImageId                The image's id, which is unique within PackageList.
     65   @param  Image                  Points to the image.
     66 
     67   @retval EFI_SUCCESS            The new image was returned successfully.
     68   @retval EFI_NOT_FOUND          The image specified by ImageId is not available. The specified
     69                                  PackageList is not in the Database.
     70   @retval EFI_INVALID_PARAMETER  Image was NULL or ImageId was 0.
     71   @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there
     72                                  was not enough memory.
     73 
     74 **/
     75 EFI_STATUS
     76 EFIAPI
     77 HiiGetImageEx (
     78   IN  CONST EFI_HII_IMAGE_EX_PROTOCOL *This,
     79   IN  EFI_HII_HANDLE                  PackageList,
     80   IN  EFI_IMAGE_ID                    ImageId,
     81   OUT EFI_IMAGE_INPUT                 *Image
     82   )
     83 {
     84   HII_DATABASE_PRIVATE_DATA           *Private;
     85 
     86   Private = HII_IMAGE_EX_DATABASE_PRIVATE_DATA_FROM_THIS (This);
     87   return IGetImage (&Private->DatabaseList, PackageList, ImageId, Image, FALSE);
     88 }
     89 
     90 
     91 /**
     92   Change the information about the image.
     93 
     94   Same with EFI_HII_IMAGE_PROTOCOL.SetImage(),this protocol invokes
     95   EFI_HII_IMAGE_PROTOCOL.SetImage()implicitly.
     96 
     97   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
     98   @param  PackageList            The package list containing the images.
     99   @param  ImageId                The image's id, which is unique within PackageList.
    100   @param  Image                  Points to the image.
    101 
    102   @retval EFI_SUCCESS            The new image was successfully updated.
    103   @retval EFI_NOT_FOUND          The image specified by ImageId is not in the
    104                                  database. The specified PackageList is not in
    105                                  the database.
    106   @retval EFI_INVALID_PARAMETER  The Image was NULL, the ImageId was 0 or
    107                                  the Image->Bitmap was NULL.
    108 
    109 **/
    110 EFI_STATUS
    111 EFIAPI
    112 HiiSetImageEx (
    113   IN CONST EFI_HII_IMAGE_EX_PROTOCOL *This,
    114   IN EFI_HII_HANDLE                  PackageList,
    115   IN EFI_IMAGE_ID                    ImageId,
    116   IN CONST EFI_IMAGE_INPUT           *Image
    117   )
    118 {
    119   HII_DATABASE_PRIVATE_DATA           *Private;
    120   Private = HII_IMAGE_EX_DATABASE_PRIVATE_DATA_FROM_THIS (This);
    121   return HiiSetImage (&Private->HiiImage, PackageList, ImageId, Image);
    122 }
    123 
    124 
    125 /**
    126   Renders an image to a bitmap or to the display.
    127 
    128   The prototype of this extension function is the same with
    129   EFI_HII_IMAGE_PROTOCOL.DrawImage(). This protocol invokes
    130   EFI_HII_IMAGE_PROTOCOL.DrawImage() implicitly.
    131 
    132   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
    133   @param  Flags                  Describes how the image is to be drawn.
    134   @param  Image                  Points to the image to be displayed.
    135   @param  Blt                    If this points to a non-NULL on entry, this points
    136                                  to the image, which is Width pixels wide and
    137                                  Height pixels high.  The image will be drawn onto
    138                                  this image and  EFI_HII_DRAW_FLAG_CLIP is implied.
    139                                  If this points to a NULL on entry, then a buffer
    140                                  will be allocated to hold the generated image and
    141                                  the pointer updated on exit. It is the caller's
    142                                  responsibility to free this buffer.
    143   @param  BltX                   Specifies the offset from the left and top edge of
    144                                  the output image of the first pixel in the image.
    145   @param  BltY                   Specifies the offset from the left and top edge of
    146                                  the output image of the first pixel in the image.
    147 
    148   @retval EFI_SUCCESS            The image was successfully drawn.
    149   @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.
    150   @retval EFI_INVALID_PARAMETER  The Image or Blt was NULL.
    151 
    152 **/
    153 EFI_STATUS
    154 EFIAPI
    155 HiiDrawImageEx (
    156   IN CONST EFI_HII_IMAGE_EX_PROTOCOL *This,
    157   IN EFI_HII_DRAW_FLAGS              Flags,
    158   IN CONST EFI_IMAGE_INPUT           *Image,
    159   IN OUT EFI_IMAGE_OUTPUT            **Blt,
    160   IN UINTN                           BltX,
    161   IN UINTN                           BltY
    162   )
    163 {
    164   HII_DATABASE_PRIVATE_DATA           *Private;
    165   Private = HII_IMAGE_EX_DATABASE_PRIVATE_DATA_FROM_THIS (This);
    166   return HiiDrawImage (&Private->HiiImage, Flags, Image, Blt, BltX, BltY);
    167 }
    168 
    169 
    170 /**
    171   Renders an image to a bitmap or the screen containing the contents of the specified
    172   image.
    173 
    174   This function is similar to EFI_HII_IMAGE_PROTOCOL.DrawImageId(). The difference is that
    175   this function will locate all EFI_HII_IMAGE_DECODER_PROTOCOL instances installed in the
    176   system if the decoder of the certain image type is not supported by the
    177   EFI_HII_IMAGE_EX_PROTOCOL. The function will attempt to decode the image to the
    178   EFI_IMAGE_INPUT using the first EFI_HII_IMAGE_DECODER_PROTOCOL instance that
    179   supports the requested image type.
    180 
    181   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
    182   @param  Flags                  Describes how the image is to be drawn.
    183   @param  PackageList            The package list in the HII database to search for
    184                                  the  specified image.
    185   @param  ImageId                The image's id, which is unique within PackageList.
    186   @param  Blt                    If this points to a non-NULL on entry, this points
    187                                  to the image, which is Width pixels wide and
    188                                  Height pixels high. The image will be drawn onto
    189                                  this image and EFI_HII_DRAW_FLAG_CLIP is implied.
    190                                  If this points to a NULL on entry, then a buffer
    191                                  will be allocated to hold  the generated image
    192                                  and the pointer updated on exit. It is the caller's
    193                                  responsibility to free this buffer.
    194   @param  BltX                   Specifies the offset from the left and top edge of
    195                                  the output image of the first pixel in the image.
    196   @param  BltY                   Specifies the offset from the left and top edge of
    197                                  the output image of the first pixel in the image.
    198 
    199   @retval EFI_SUCCESS            The image was successfully drawn.
    200   @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.
    201   @retval EFI_INVALID_PARAMETER  The Blt was NULL or ImageId was 0.
    202   @retval EFI_NOT_FOUND          The image specified by ImageId is not in the database.
    203                                  The specified PackageList is not in the database.
    204 
    205 **/
    206 EFI_STATUS
    207 EFIAPI
    208 HiiDrawImageIdEx (
    209   IN CONST EFI_HII_IMAGE_EX_PROTOCOL *This,
    210   IN EFI_HII_DRAW_FLAGS              Flags,
    211   IN EFI_HII_HANDLE                  PackageList,
    212   IN EFI_IMAGE_ID                    ImageId,
    213   IN OUT EFI_IMAGE_OUTPUT            **Blt,
    214   IN UINTN                           BltX,
    215   IN UINTN                           BltY
    216   )
    217 {
    218   EFI_STATUS                          Status;
    219   EFI_IMAGE_INPUT                     Image;
    220 
    221   //
    222   // Check input parameter.
    223   //
    224   if (This == NULL || Blt == NULL) {
    225     return EFI_INVALID_PARAMETER;
    226   }
    227 
    228   //
    229   // Get the specified Image.
    230   //
    231   Status = HiiGetImageEx (This, PackageList, ImageId, &Image);
    232   if (EFI_ERROR (Status)) {
    233     return Status;
    234   }
    235 
    236   //
    237   // Draw this image.
    238   //
    239   Status = HiiDrawImageEx (This, Flags, &Image, Blt, BltX, BltY);
    240   if (Image.Bitmap != NULL) {
    241     FreePool (Image.Bitmap);
    242   }
    243   return Status;
    244 }
    245 
    246 /**
    247   Return the first HII image decoder instance which supports the DecoderName.
    248 
    249   @param BlockType  The image block type.
    250 
    251   @retval Pointer to the HII image decoder instance.
    252 **/
    253 EFI_HII_IMAGE_DECODER_PROTOCOL *
    254 LocateHiiImageDecoder (
    255   UINT8                          BlockType
    256   )
    257 {
    258   EFI_STATUS                     Status;
    259   EFI_HII_IMAGE_DECODER_PROTOCOL *Decoder;
    260   EFI_HANDLE                     *Handles;
    261   UINTN                          HandleNum;
    262   UINTN                          Index;
    263   EFI_GUID                       *DecoderNames;
    264   UINT16                         NumberOfDecoderName;
    265   UINT16                         DecoderNameIndex;
    266   EFI_GUID                       *DecoderName;
    267 
    268   switch (BlockType) {
    269   case EFI_HII_IIBT_IMAGE_JPEG:
    270     DecoderName = &gEfiHiiImageDecoderNameJpegGuid;
    271     break;
    272 
    273   case EFI_HII_IIBT_IMAGE_PNG:
    274     DecoderName = &gEfiHiiImageDecoderNamePngGuid;
    275     break;
    276 
    277   default:
    278     ASSERT (FALSE);
    279     return NULL;
    280   }
    281 
    282   Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiHiiImageDecoderProtocolGuid, NULL, &HandleNum, &Handles);
    283   if (EFI_ERROR (Status)) {
    284     return NULL;
    285   }
    286   for (Index = 0; Index < HandleNum; Index++) {
    287     Status = gBS->HandleProtocol (Handles[Index], &gEfiHiiImageDecoderProtocolGuid, (VOID **) &Decoder);
    288     if (EFI_ERROR (Status)) {
    289       continue;
    290     }
    291 
    292     Status = Decoder->GetImageDecoderName (Decoder, &DecoderNames, &NumberOfDecoderName);
    293     if (EFI_ERROR (Status)) {
    294       continue;
    295     }
    296     for (DecoderNameIndex = 0; DecoderNameIndex < NumberOfDecoderName; DecoderNameIndex++) {
    297       if (CompareGuid (DecoderName, &DecoderNames[DecoderNameIndex])) {
    298         return Decoder;
    299       }
    300     }
    301   }
    302 
    303   return NULL;
    304 }
    305 
    306 /**
    307   This function returns the image information to EFI_IMAGE_OUTPUT. Only the width
    308   and height are returned to the EFI_IMAGE_OUTPUT instead of decoding the image
    309   to the buffer. This function is used to get the geometry of the image. This function
    310   will try to locate all of the EFI_HII_IMAGE_DECODER_PROTOCOL installed on the
    311   system if the decoder of image type is not supported by the EFI_HII_IMAGE_EX_PROTOCOL.
    312 
    313   @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
    314   @param  PackageList            Handle of the package list where this image will
    315                                  be searched.
    316   @param  ImageId                The image's id, which is unique within PackageList.
    317   @param  Image                  Points to the image.
    318 
    319   @retval EFI_SUCCESS            The new image was returned successfully.
    320   @retval EFI_NOT_FOUND          The image specified by ImageId is not in the
    321                                  database. The specified PackageList is not in the database.
    322   @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to
    323                                  hold the image.
    324   @retval EFI_INVALID_PARAMETER  The Image was NULL or the ImageId was 0.
    325   @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there
    326                                  was not enough memory.
    327 
    328 **/
    329 EFI_STATUS
    330 EFIAPI
    331 HiiGetImageInfo (
    332   IN CONST  EFI_HII_IMAGE_EX_PROTOCOL       *This,
    333   IN        EFI_HII_HANDLE                  PackageList,
    334   IN        EFI_IMAGE_ID                    ImageId,
    335   OUT       EFI_IMAGE_OUTPUT                *Image
    336   )
    337 {
    338   EFI_STATUS                              Status;
    339   HII_DATABASE_PRIVATE_DATA               *Private;
    340   HII_DATABASE_PACKAGE_LIST_INSTANCE      *PackageListNode;
    341   HII_IMAGE_PACKAGE_INSTANCE              *ImagePackage;
    342   EFI_HII_IMAGE_BLOCK                     *CurrentImageBlock;
    343   EFI_HII_IMAGE_DECODER_PROTOCOL          *Decoder;
    344   EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER *ImageInfo;
    345 
    346   if (Image == NULL || ImageId == 0) {
    347     return EFI_INVALID_PARAMETER;
    348   }
    349 
    350   Private = HII_IMAGE_EX_DATABASE_PRIVATE_DATA_FROM_THIS (This);
    351   PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);
    352   if (PackageListNode == NULL) {
    353     return EFI_NOT_FOUND;
    354   }
    355   ImagePackage = PackageListNode->ImagePkg;
    356   if (ImagePackage == NULL) {
    357     return EFI_NOT_FOUND;
    358   }
    359 
    360   //
    361   // Find the image block specified by ImageId
    362   //
    363   CurrentImageBlock = GetImageIdOrAddress (ImagePackage->ImageBlock, &ImageId);
    364   if (CurrentImageBlock == NULL) {
    365     return EFI_NOT_FOUND;
    366   }
    367 
    368   switch (CurrentImageBlock->BlockType) {
    369   case EFI_HII_IIBT_IMAGE_JPEG:
    370   case EFI_HII_IIBT_IMAGE_PNG:
    371     Decoder = LocateHiiImageDecoder (CurrentImageBlock->BlockType);
    372     if (Decoder == NULL) {
    373       return EFI_UNSUPPORTED;
    374     }
    375     //
    376     // Use the common block code since the definition of two structures is the same.
    377     //
    378     ASSERT (OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Data) == OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Data));
    379     ASSERT (sizeof (((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Data) ==
    380             sizeof (((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Data));
    381     ASSERT (OFFSET_OF (EFI_HII_IIBT_JPEG_BLOCK, Size) == OFFSET_OF (EFI_HII_IIBT_PNG_BLOCK, Size));
    382     ASSERT (sizeof (((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size) ==
    383             sizeof (((EFI_HII_IIBT_PNG_BLOCK *) CurrentImageBlock)->Size));
    384     Status = Decoder->GetImageInfo (
    385       Decoder,
    386       ((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Data,
    387       ((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size,
    388       &ImageInfo
    389     );
    390 
    391     //
    392     // Spec requires to use the first capable image decoder instance.
    393     // The first image decoder instance may fail to decode the image.
    394     //
    395     if (!EFI_ERROR (Status)) {
    396       Image->Height = ImageInfo->ImageHeight;
    397       Image->Width = ImageInfo->ImageWidth;
    398       Image->Image.Bitmap = NULL;
    399       FreePool (ImageInfo);
    400     }
    401     return Status;
    402 
    403   case EFI_HII_IIBT_IMAGE_1BIT_TRANS:
    404   case EFI_HII_IIBT_IMAGE_4BIT_TRANS:
    405   case EFI_HII_IIBT_IMAGE_8BIT_TRANS:
    406   case EFI_HII_IIBT_IMAGE_1BIT:
    407   case EFI_HII_IIBT_IMAGE_4BIT:
    408   case EFI_HII_IIBT_IMAGE_8BIT:
    409     //
    410     // Use the common block code since the definition of these structures is the same.
    411     //
    412     Image->Width = ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width);
    413     Image->Height = ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height);
    414     Image->Image.Bitmap = NULL;
    415     return EFI_SUCCESS;
    416 
    417   case EFI_HII_IIBT_IMAGE_24BIT_TRANS:
    418   case EFI_HII_IIBT_IMAGE_24BIT:
    419     Image->Width = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width);
    420     Image->Height = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height);
    421     Image->Image.Bitmap = NULL;
    422     return EFI_SUCCESS;
    423 
    424   default:
    425     return EFI_NOT_FOUND;
    426   }
    427 }
    428