]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/HiiDatabaseDxe/Image.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg/HiiDatabase: Refine HiiNewImage()
[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / Image.c
1 /** @file
2 Implementation for EFI_HII_IMAGE_PROTOCOL.
3
4
5 Copyright (c) 2007 - 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 /**
21 Get the imageid of last image block: EFI_HII_IIBT_END_BLOCK when input
22 ImageId is zero, otherwise return the address of the
23 corresponding image block with identifier specified by ImageId.
24
25 This is a internal function.
26
27 @param ImageBlocks Points to the beginning of a series of image blocks stored in order.
28 @param ImageId If input ImageId is 0, output the image id of the EFI_HII_IIBT_END_BLOCK;
29 else use this id to find its corresponding image block address.
30
31 @return The image block address when input ImageId is not zero; otherwise return NULL.
32
33 **/
34 EFI_HII_IMAGE_BLOCK *
35 GetImageIdOrAddress (
36 IN EFI_HII_IMAGE_BLOCK *ImageBlocks,
37 IN OUT EFI_IMAGE_ID *ImageId
38 )
39 {
40 EFI_IMAGE_ID ImageIdCurrent;
41 EFI_HII_IMAGE_BLOCK *CurrentImageBlock;
42 UINTN Length;
43
44 ASSERT (ImageBlocks != NULL && ImageId != NULL);
45 CurrentImageBlock = ImageBlocks;
46 ImageIdCurrent = 1;
47
48 while (CurrentImageBlock->BlockType != EFI_HII_IIBT_END) {
49 if (*ImageId != 0) {
50 if (*ImageId == ImageIdCurrent) {
51 //
52 // If the found image block is a duplicate block, update the ImageId to
53 // find the previous defined image block.
54 //
55 if (CurrentImageBlock->BlockType == EFI_HII_IIBT_DUPLICATE) {
56 *ImageId = ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_DUPLICATE_BLOCK *) CurrentImageBlock)->ImageId);
57 ASSERT (*ImageId != ImageIdCurrent);
58 ASSERT (*ImageId != 0);
59 CurrentImageBlock = ImageBlocks;
60 ImageIdCurrent = 1;
61 continue;
62 }
63
64 return CurrentImageBlock;
65 }
66 if (*ImageId < ImageIdCurrent) {
67 //
68 // Can not find the specified image block in this image.
69 //
70 return NULL;
71 }
72 }
73 switch (CurrentImageBlock->BlockType) {
74 case EFI_HII_IIBT_EXT1:
75 Length = ((EFI_HII_IIBT_EXT1_BLOCK *) CurrentImageBlock)->Length;
76 break;
77 case EFI_HII_IIBT_EXT2:
78 Length = ReadUnaligned16 (&((EFI_HII_IIBT_EXT2_BLOCK *) CurrentImageBlock)->Length);
79 break;
80 case EFI_HII_IIBT_EXT4:
81 Length = ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_EXT4_BLOCK *) CurrentImageBlock)->Length);
82 break;
83
84 case EFI_HII_IIBT_IMAGE_1BIT:
85 case EFI_HII_IIBT_IMAGE_1BIT_TRANS:
86 Length = sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8) +
87 BITMAP_LEN_1_BIT (
88 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),
89 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_1BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)
90 );
91 ImageIdCurrent++;
92 break;
93
94 case EFI_HII_IIBT_IMAGE_4BIT:
95 case EFI_HII_IIBT_IMAGE_4BIT_TRANS:
96 Length = sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8) +
97 BITMAP_LEN_4_BIT (
98 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_4BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),
99 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_4BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)
100 );
101 ImageIdCurrent++;
102 break;
103
104 case EFI_HII_IIBT_IMAGE_8BIT:
105 case EFI_HII_IIBT_IMAGE_8BIT_TRANS:
106 Length = sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +
107 BITMAP_LEN_8_BIT (
108 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),
109 ReadUnaligned16 (&((EFI_HII_IIBT_IMAGE_8BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)
110 );
111 ImageIdCurrent++;
112 break;
113
114 case EFI_HII_IIBT_IMAGE_24BIT:
115 case EFI_HII_IIBT_IMAGE_24BIT_TRANS:
116 Length = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +
117 BITMAP_LEN_24_BIT (
118 ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Width),
119 ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) CurrentImageBlock)->Bitmap.Height)
120 );
121 ImageIdCurrent++;
122 break;
123
124 case EFI_HII_IIBT_DUPLICATE:
125 Length = sizeof (EFI_HII_IIBT_DUPLICATE_BLOCK);
126 ImageIdCurrent++;
127 break;
128
129 case EFI_HII_IIBT_IMAGE_JPEG:
130 Length = ReadUnaligned32 ((VOID *) &((EFI_HII_IIBT_JPEG_BLOCK *) CurrentImageBlock)->Size);
131 ImageIdCurrent++;
132 break;
133
134 case EFI_HII_IIBT_SKIP1:
135 Length = sizeof (EFI_HII_IIBT_SKIP1_BLOCK);
136 ImageIdCurrent += ((EFI_HII_IIBT_SKIP1_BLOCK *) CurrentImageBlock)->SkipCount;
137 break;
138
139 case EFI_HII_IIBT_SKIP2:
140 Length = sizeof (EFI_HII_IIBT_SKIP2_BLOCK);
141 ImageIdCurrent += ReadUnaligned16 ((VOID *) &((EFI_HII_IIBT_SKIP2_BLOCK *) CurrentImageBlock)->SkipCount);
142 break;
143
144 default:
145 //
146 // Unknown image blocks can not be skipped, processing halts.
147 //
148 ASSERT (FALSE);
149 Length = 0;
150 break;
151 }
152
153 CurrentImageBlock = (EFI_HII_IMAGE_BLOCK *) ((UINT8 *) CurrentImageBlock + Length);
154
155 }
156
157 //
158 // When ImageId is zero, return the imageid of last image block: EFI_HII_IIBT_END_BLOCK.
159 //
160 if (*ImageId == 0) {
161 *ImageId = ImageIdCurrent;
162 return CurrentImageBlock;
163 }
164
165 return NULL;
166 }
167
168
169
170 /**
171 Convert pixels from EFI_GRAPHICS_OUTPUT_BLT_PIXEL to EFI_HII_RGB_PIXEL style.
172
173 This is a internal function.
174
175
176 @param BitMapOut Pixels in EFI_HII_RGB_PIXEL format.
177 @param BitMapIn Pixels in EFI_GRAPHICS_OUTPUT_BLT_PIXEL format.
178 @param PixelNum The number of pixels to be converted.
179
180
181 **/
182 VOID
183 CopyGopToRgbPixel (
184 OUT EFI_HII_RGB_PIXEL *BitMapOut,
185 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapIn,
186 IN UINTN PixelNum
187 )
188 {
189 UINTN Index;
190
191 ASSERT (BitMapOut != NULL && BitMapIn != NULL);
192
193 for (Index = 0; Index < PixelNum; Index++) {
194 CopyMem (BitMapOut + Index, BitMapIn + Index, sizeof (EFI_HII_RGB_PIXEL));
195 }
196 }
197
198
199 /**
200 Convert pixels from EFI_HII_RGB_PIXEL to EFI_GRAPHICS_OUTPUT_BLT_PIXEL style.
201
202 This is a internal function.
203
204
205 @param BitMapOut Pixels in EFI_GRAPHICS_OUTPUT_BLT_PIXEL format.
206 @param BitMapIn Pixels in EFI_HII_RGB_PIXEL format.
207 @param PixelNum The number of pixels to be converted.
208
209
210 **/
211 VOID
212 CopyRgbToGopPixel (
213 OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapOut,
214 IN EFI_HII_RGB_PIXEL *BitMapIn,
215 IN UINTN PixelNum
216 )
217 {
218 UINTN Index;
219
220 ASSERT (BitMapOut != NULL && BitMapIn != NULL);
221
222 for (Index = 0; Index < PixelNum; Index++) {
223 CopyMem (BitMapOut + Index, BitMapIn + Index, sizeof (EFI_HII_RGB_PIXEL));
224 }
225 }
226
227
228 /**
229 Output pixels in "1 bit per pixel" format to an image.
230
231 This is a internal function.
232
233
234 @param Image Points to the image which will store the pixels.
235 @param Data Stores the value of output pixels, 0 or 1.
236 @param PaletteInfo PaletteInfo which stores the color of the output
237 pixels. First entry corresponds to color 0 and
238 second one to color 1.
239
240
241 **/
242 VOID
243 Output1bitPixel (
244 IN OUT EFI_IMAGE_INPUT *Image,
245 IN UINT8 *Data,
246 IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo
247 )
248 {
249 UINT16 Xpos;
250 UINT16 Ypos;
251 UINTN OffsetY;
252 UINT8 Index;
253 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;
254 EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[2];
255 EFI_HII_IMAGE_PALETTE_INFO *Palette;
256 UINTN PaletteSize;
257 UINT8 Byte;
258
259 ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);
260
261 BitMapPtr = Image->Bitmap;
262
263 //
264 // First entry corresponds to color 0 and second entry corresponds to color 1.
265 //
266 PaletteSize = 0;
267 CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));
268 PaletteSize += sizeof (UINT16);
269 Palette = AllocateZeroPool (PaletteSize);
270 ASSERT (Palette != NULL);
271 if (Palette == NULL) {
272 return;
273 }
274 CopyMem (Palette, PaletteInfo, PaletteSize);
275
276 ZeroMem (PaletteValue, sizeof (PaletteValue));
277 CopyRgbToGopPixel (&PaletteValue[0], &Palette->PaletteValue[0], 1);
278 CopyRgbToGopPixel (&PaletteValue[1], &Palette->PaletteValue[1], 1);
279 FreePool (Palette);
280
281 //
282 // Convert the pixel from one bit to corresponding color.
283 //
284 for (Ypos = 0; Ypos < Image->Height; Ypos++) {
285 OffsetY = BITMAP_LEN_1_BIT (Image->Width, Ypos);
286 //
287 // All bits in these bytes are meaningful
288 //
289 for (Xpos = 0; Xpos < Image->Width / 8; Xpos++) {
290 Byte = *(Data + OffsetY + Xpos);
291 for (Index = 0; Index < 8; Index++) {
292 if ((Byte & (1 << Index)) != 0) {
293 BitMapPtr[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[1];
294 } else {
295 BitMapPtr[Ypos * Image->Width + Xpos * 8 + (8 - Index - 1)] = PaletteValue[0];
296 }
297 }
298 }
299
300 if (Image->Width % 8 != 0) {
301 //
302 // Padding bits in this byte should be ignored.
303 //
304 Byte = *(Data + OffsetY + Xpos);
305 for (Index = 0; Index < Image->Width % 8; Index++) {
306 if ((Byte & (1 << (8 - Index - 1))) != 0) {
307 BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[1];
308 } else {
309 BitMapPtr[Ypos * Image->Width + Xpos * 8 + Index] = PaletteValue[0];
310 }
311 }
312 }
313 }
314 }
315
316
317 /**
318 Output pixels in "4 bit per pixel" format to an image.
319
320 This is a internal function.
321
322
323 @param Image Points to the image which will store the pixels.
324 @param Data Stores the value of output pixels, 0 ~ 15.
325 @param[in] PaletteInfo PaletteInfo which stores the color of the output
326 pixels. Each entry corresponds to a color within
327 [0, 15].
328
329
330 **/
331 VOID
332 Output4bitPixel (
333 IN OUT EFI_IMAGE_INPUT *Image,
334 IN UINT8 *Data,
335 IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo
336 )
337 {
338 UINT16 Xpos;
339 UINT16 Ypos;
340 UINTN OffsetY;
341 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;
342 EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[16];
343 EFI_HII_IMAGE_PALETTE_INFO *Palette;
344 UINTN PaletteSize;
345 UINT16 PaletteNum;
346 UINT8 Byte;
347
348 ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);
349
350 BitMapPtr = Image->Bitmap;
351
352 //
353 // The bitmap should allocate each color index starting from 0.
354 //
355 PaletteSize = 0;
356 CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));
357 PaletteSize += sizeof (UINT16);
358 Palette = AllocateZeroPool (PaletteSize);
359 ASSERT (Palette != NULL);
360 if (Palette == NULL) {
361 return;
362 }
363 CopyMem (Palette, PaletteInfo, PaletteSize);
364 PaletteNum = (UINT16)(Palette->PaletteSize / sizeof (EFI_HII_RGB_PIXEL));
365
366 ZeroMem (PaletteValue, sizeof (PaletteValue));
367 CopyRgbToGopPixel (PaletteValue, Palette->PaletteValue, PaletteNum);
368 FreePool (Palette);
369
370 //
371 // Convert the pixel from 4 bit to corresponding color.
372 //
373 for (Ypos = 0; Ypos < Image->Height; Ypos++) {
374 OffsetY = BITMAP_LEN_4_BIT (Image->Width, Ypos);
375 //
376 // All bits in these bytes are meaningful
377 //
378 for (Xpos = 0; Xpos < Image->Width / 2; Xpos++) {
379 Byte = *(Data + OffsetY + Xpos);
380 BitMapPtr[Ypos * Image->Width + Xpos * 2] = PaletteValue[Byte >> 4];
381 BitMapPtr[Ypos * Image->Width + Xpos * 2 + 1] = PaletteValue[Byte & 0x0F];
382 }
383
384 if (Image->Width % 2 != 0) {
385 //
386 // Padding bits in this byte should be ignored.
387 //
388 Byte = *(Data + OffsetY + Xpos);
389 BitMapPtr[Ypos * Image->Width + Xpos * 2] = PaletteValue[Byte >> 4];
390 }
391 }
392 }
393
394
395 /**
396 Output pixels in "8 bit per pixel" format to an image.
397
398 This is a internal function.
399
400
401 @param Image Points to the image which will store the pixels.
402 @param Data Stores the value of output pixels, 0 ~ 255.
403 @param[in] PaletteInfo PaletteInfo which stores the color of the output
404 pixels. Each entry corresponds to a color within
405 [0, 255].
406
407
408 **/
409 VOID
410 Output8bitPixel (
411 IN OUT EFI_IMAGE_INPUT *Image,
412 IN UINT8 *Data,
413 IN EFI_HII_IMAGE_PALETTE_INFO *PaletteInfo
414 )
415 {
416 UINT16 Xpos;
417 UINT16 Ypos;
418 UINTN OffsetY;
419 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;
420 EFI_GRAPHICS_OUTPUT_BLT_PIXEL PaletteValue[256];
421 EFI_HII_IMAGE_PALETTE_INFO *Palette;
422 UINTN PaletteSize;
423 UINT16 PaletteNum;
424 UINT8 Byte;
425
426 ASSERT (Image != NULL && Data != NULL && PaletteInfo != NULL);
427
428 BitMapPtr = Image->Bitmap;
429
430 //
431 // The bitmap should allocate each color index starting from 0.
432 //
433 PaletteSize = 0;
434 CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));
435 PaletteSize += sizeof (UINT16);
436 Palette = AllocateZeroPool (PaletteSize);
437 ASSERT (Palette != NULL);
438 if (Palette == NULL) {
439 return;
440 }
441 CopyMem (Palette, PaletteInfo, PaletteSize);
442 PaletteNum = (UINT16)(Palette->PaletteSize / sizeof (EFI_HII_RGB_PIXEL));
443 ZeroMem (PaletteValue, sizeof (PaletteValue));
444 CopyRgbToGopPixel (PaletteValue, Palette->PaletteValue, PaletteNum);
445 FreePool (Palette);
446
447 //
448 // Convert the pixel from 8 bits to corresponding color.
449 //
450 for (Ypos = 0; Ypos < Image->Height; Ypos++) {
451 OffsetY = BITMAP_LEN_8_BIT (Image->Width, Ypos);
452 //
453 // All bits are meaningful since the bitmap is 8 bits per pixel.
454 //
455 for (Xpos = 0; Xpos < Image->Width; Xpos++) {
456 Byte = *(Data + OffsetY + Xpos);
457 BitMapPtr[OffsetY + Xpos] = PaletteValue[Byte];
458 }
459 }
460
461 }
462
463
464 /**
465 Output pixels in "24 bit per pixel" format to an image.
466
467 This is a internal function.
468
469
470 @param Image Points to the image which will store the pixels.
471 @param Data Stores the color of output pixels, allowing 16.8
472 millions colors.
473
474
475 **/
476 VOID
477 Output24bitPixel (
478 IN OUT EFI_IMAGE_INPUT *Image,
479 IN EFI_HII_RGB_PIXEL *Data
480 )
481 {
482 UINT16 Ypos;
483 UINTN OffsetY;
484 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BitMapPtr;
485
486 ASSERT (Image != NULL && Data != NULL);
487
488 BitMapPtr = Image->Bitmap;
489
490 for (Ypos = 0; Ypos < Image->Height; Ypos++) {
491 OffsetY = BITMAP_LEN_8_BIT (Image->Width, Ypos);
492 CopyRgbToGopPixel (&BitMapPtr[OffsetY], &Data[OffsetY], Image->Width);
493 }
494
495 }
496
497
498 /**
499 Convert the image from EFI_IMAGE_INPUT to EFI_IMAGE_OUTPUT format.
500
501 This is a internal function.
502
503
504 @param BltBuffer Buffer points to bitmap data of incoming image.
505 @param BltX Specifies the offset from the left and top edge of
506 the output image of the first pixel in the image.
507 @param BltY Specifies the offset from the left and top edge of
508 the output image of the first pixel in the image.
509 @param Width Width of the incoming image, in pixels.
510 @param Height Height of the incoming image, in pixels.
511 @param Transparent If TRUE, all "off" pixels in the image will be
512 drawn using the pixel value from blt and all other
513 pixels will be copied.
514 @param Blt Buffer points to bitmap data of output image.
515
516 @retval EFI_SUCCESS The image was successfully converted.
517 @retval EFI_INVALID_PARAMETER Any incoming parameter is invalid.
518
519 **/
520 EFI_STATUS
521 ImageToBlt (
522 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
523 IN UINTN BltX,
524 IN UINTN BltY,
525 IN UINTN Width,
526 IN UINTN Height,
527 IN BOOLEAN Transparent,
528 IN OUT EFI_IMAGE_OUTPUT **Blt
529 )
530 {
531 EFI_IMAGE_OUTPUT *ImageOut;
532 UINTN Xpos;
533 UINTN Ypos;
534 UINTN OffsetY1; // src buffer
535 UINTN OffsetY2; // dest buffer
536 EFI_GRAPHICS_OUTPUT_BLT_PIXEL SrcPixel;
537 EFI_GRAPHICS_OUTPUT_BLT_PIXEL ZeroPixel;
538
539 if (BltBuffer == NULL || Blt == NULL || *Blt == NULL) {
540 return EFI_INVALID_PARAMETER;
541 }
542
543 ImageOut = *Blt;
544
545 if (Width + BltX > ImageOut->Width) {
546 return EFI_INVALID_PARAMETER;
547 }
548 if (Height + BltY > ImageOut->Height) {
549 return EFI_INVALID_PARAMETER;
550 }
551
552 ZeroMem (&ZeroPixel, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
553
554 for (Ypos = 0; Ypos < Height; Ypos++) {
555 OffsetY1 = Width * Ypos;
556 OffsetY2 = ImageOut->Width * (BltY + Ypos);
557 for (Xpos = 0; Xpos < Width; Xpos++) {
558 SrcPixel = BltBuffer[OffsetY1 + Xpos];
559 if (Transparent) {
560 if (CompareMem (&SrcPixel, &ZeroPixel, 3) != 0) {
561 ImageOut->Image.Bitmap[OffsetY2 + BltX + Xpos] = SrcPixel;
562 }
563 } else {
564 ImageOut->Image.Bitmap[OffsetY2 + BltX + Xpos] = SrcPixel;
565 }
566 }
567 }
568
569 return EFI_SUCCESS;
570 }
571
572 /**
573 Return the HII package list identified by PackageList HII handle.
574
575 @param Database Pointer to HII database list header.
576 @param PackageList HII handle of the package list to locate.
577
578 @retval The HII package list instance.
579 **/
580 HII_DATABASE_PACKAGE_LIST_INSTANCE *
581 LocatePackageList (
582 IN LIST_ENTRY *Database,
583 IN EFI_HII_HANDLE PackageList
584 )
585 {
586 LIST_ENTRY *Link;
587 HII_DATABASE_RECORD *Record;
588
589 //
590 // Get the specified package list and image package.
591 //
592 for (Link = GetFirstNode (Database);
593 !IsNull (Database, Link);
594 Link = GetNextNode (Database, Link)
595 ) {
596 Record = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
597 if (Record->Handle == PackageList) {
598 return Record->PackageList;
599 }
600 }
601 return NULL;
602 }
603
604 /**
605 This function adds the image Image to the group of images owned by PackageList, and returns
606 a new image identifier (ImageId).
607
608 @param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
609 @param PackageList Handle of the package list where this image will
610 be added.
611 @param ImageId On return, contains the new image id, which is
612 unique within PackageList.
613 @param Image Points to the image.
614
615 @retval EFI_SUCCESS The new image was added successfully.
616 @retval EFI_NOT_FOUND The specified PackageList could not be found in
617 database.
618 @retval EFI_OUT_OF_RESOURCES Could not add the image due to lack of resources.
619 @retval EFI_INVALID_PARAMETER Image is NULL or ImageId is NULL.
620
621 **/
622 EFI_STATUS
623 EFIAPI
624 HiiNewImage (
625 IN CONST EFI_HII_IMAGE_PROTOCOL *This,
626 IN EFI_HII_HANDLE PackageList,
627 OUT EFI_IMAGE_ID *ImageId,
628 IN CONST EFI_IMAGE_INPUT *Image
629 )
630 {
631 HII_DATABASE_PRIVATE_DATA *Private;
632 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
633 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
634 EFI_HII_IMAGE_BLOCK *ImageBlocks;
635 UINT32 NewBlockSize;
636
637 if (This == NULL || ImageId == NULL || Image == NULL || Image->Bitmap == NULL) {
638 return EFI_INVALID_PARAMETER;
639 }
640
641 if (!IsHiiHandleValid (PackageList)) {
642 return EFI_NOT_FOUND;
643 }
644
645 Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
646 PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);
647 if (PackageListNode == NULL) {
648 return EFI_NOT_FOUND;
649 }
650
651 NewBlockSize = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +
652 BITMAP_LEN_24_BIT (Image->Width, Image->Height);
653
654 //
655 // Get the image package in the package list,
656 // or create a new image package if image package does not exist.
657 //
658 if (PackageListNode->ImagePkg != NULL) {
659 ImagePackage = PackageListNode->ImagePkg;
660
661 //
662 // Output the image id of the incoming image being inserted, which is the
663 // image id of the EFI_HII_IIBT_END block of old image package.
664 //
665 *ImageId = 0;
666 GetImageIdOrAddress (ImagePackage->ImageBlock, ImageId);
667
668 //
669 // Update the package's image block by appending the new block to the end.
670 //
671 ImageBlocks = AllocatePool (ImagePackage->ImageBlockSize + NewBlockSize);
672 if (ImageBlocks == NULL) {
673 return EFI_OUT_OF_RESOURCES;
674 }
675 //
676 // Copy the original content.
677 //
678 CopyMem (
679 ImageBlocks,
680 ImagePackage->ImageBlock,
681 ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)
682 );
683 FreePool (ImagePackage->ImageBlock);
684 ImagePackage->ImageBlock = ImageBlocks;
685
686 //
687 // Point to the very last block.
688 //
689 ImageBlocks = (EFI_HII_IMAGE_BLOCK *) (
690 (UINT8 *) ImageBlocks + ImagePackage->ImageBlockSize - sizeof (EFI_HII_IIBT_END_BLOCK)
691 );
692 //
693 // Update the length record.
694 //
695 ImagePackage->ImageBlockSize += NewBlockSize;
696 ImagePackage->ImagePkgHdr.Header.Length += NewBlockSize;
697 PackageListNode->PackageListHdr.PackageLength += NewBlockSize;
698
699 } else {
700 //
701 // The specified package list does not contain image package.
702 // Create one to add this image block.
703 //
704 ImagePackage = (HII_IMAGE_PACKAGE_INSTANCE *) AllocateZeroPool (sizeof (HII_IMAGE_PACKAGE_INSTANCE));
705 if (ImagePackage == NULL) {
706 return EFI_OUT_OF_RESOURCES;
707 }
708 //
709 // Output the image id of the incoming image being inserted, which is the
710 // first image block so that id is initially to one.
711 //
712 *ImageId = 1;
713 //
714 // Fill in image package header.
715 //
716 ImagePackage->ImagePkgHdr.Header.Length = sizeof (EFI_HII_IMAGE_PACKAGE_HDR) + NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK);
717 ImagePackage->ImagePkgHdr.Header.Type = EFI_HII_PACKAGE_IMAGES;
718 ImagePackage->ImagePkgHdr.ImageInfoOffset = sizeof (EFI_HII_IMAGE_PACKAGE_HDR);
719 ImagePackage->ImagePkgHdr.PaletteInfoOffset = 0;
720
721 //
722 // Fill in palette info.
723 //
724 ImagePackage->PaletteBlock = NULL;
725 ImagePackage->PaletteInfoSize = 0;
726
727 //
728 // Fill in image blocks.
729 //
730 ImagePackage->ImageBlockSize = NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK);
731 ImagePackage->ImageBlock = AllocateZeroPool (NewBlockSize + sizeof (EFI_HII_IIBT_END_BLOCK));
732 if (ImagePackage->ImageBlock == NULL) {
733 FreePool (ImagePackage);
734 return EFI_OUT_OF_RESOURCES;
735 }
736 ImageBlocks = ImagePackage->ImageBlock;
737
738 //
739 // Insert this image package.
740 //
741 PackageListNode->ImagePkg = ImagePackage;
742 PackageListNode->PackageListHdr.PackageLength += ImagePackage->ImagePkgHdr.Header.Length;
743 }
744
745 //
746 // Append the new block here
747 //
748 if (Image->Flags == EFI_IMAGE_TRANSPARENT) {
749 ImageBlocks->BlockType = EFI_HII_IIBT_IMAGE_24BIT_TRANS;
750 } else {
751 ImageBlocks->BlockType = EFI_HII_IIBT_IMAGE_24BIT;
752 }
753 WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Width, Image->Width);
754 WriteUnaligned16 ((VOID *) &((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Height, Image->Height);
755 CopyGopToRgbPixel (((EFI_HII_IIBT_IMAGE_24BIT_BLOCK *) ImageBlocks)->Bitmap.Bitmap, Image->Bitmap, Image->Width * Image->Height);
756
757 //
758 // Append the block end
759 //
760 ImageBlocks = (EFI_HII_IMAGE_BLOCK *) ((UINT8 *) ImageBlocks + NewBlockSize);
761 ImageBlocks->BlockType = EFI_HII_IIBT_END;
762
763 //
764 // Check whether need to get the contents of HiiDataBase.
765 // Only after ReadyToBoot to do the export.
766 //
767 if (gExportAfterReadyToBoot) {
768 HiiGetDatabaseInfo(&Private->HiiDatabase);
769 }
770
771 return EFI_SUCCESS;
772 }
773
774
775 /**
776 This function retrieves the image specified by ImageId which is associated with
777 the specified PackageList and copies it into the buffer specified by Image.
778
779 @param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
780 @param PackageList Handle of the package list where this image will
781 be searched.
782 @param ImageId The image's id,, which is unique within
783 PackageList.
784 @param Image Points to the image.
785
786 @retval EFI_SUCCESS The new image was returned successfully.
787 @retval EFI_NOT_FOUND The image specified by ImageId is not in the
788 database. The specified PackageList is not in the database.
789 @retval EFI_BUFFER_TOO_SMALL The buffer specified by ImageSize is too small to
790 hold the image.
791 @retval EFI_INVALID_PARAMETER The Image or ImageSize was NULL.
792 @retval EFI_OUT_OF_RESOURCES The bitmap could not be retrieved because there was not
793 enough memory.
794
795 **/
796 EFI_STATUS
797 EFIAPI
798 HiiGetImage (
799 IN CONST EFI_HII_IMAGE_PROTOCOL *This,
800 IN EFI_HII_HANDLE PackageList,
801 IN EFI_IMAGE_ID ImageId,
802 OUT EFI_IMAGE_INPUT *Image
803 )
804 {
805 HII_DATABASE_PRIVATE_DATA *Private;
806 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
807 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
808 UINT8 *ImageBlock;
809 EFI_IMAGE_ID LocalImageId;
810 UINT8 BlockType;
811 EFI_HII_IIBT_IMAGE_1BIT_BLOCK Iibt1bit;
812 UINT16 Width;
813 UINT16 Height;
814 UINTN ImageLength;
815 BOOLEAN Flag;
816 UINT8 *PaletteInfo;
817 UINT8 PaletteIndex;
818 UINT16 PaletteSize;
819
820 if (This == NULL || Image == NULL || ImageId < 1) {
821 return EFI_INVALID_PARAMETER;
822 }
823
824 if (!IsHiiHandleValid (PackageList)) {
825 return EFI_NOT_FOUND;
826 }
827
828 Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
829 PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);
830 if (PackageListNode == NULL) {
831 return EFI_NOT_FOUND;
832 }
833 ImagePackage = PackageListNode->ImagePkg;
834 if (ImagePackage == NULL) {
835 return EFI_NOT_FOUND;
836 }
837
838 //
839 // Find the image block specified by ImageId
840 //
841 LocalImageId = ImageId;
842 ImageBlock = (UINT8 *) GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);
843 if (ImageBlock == NULL) {
844 return EFI_NOT_FOUND;
845 }
846
847 Flag = FALSE;
848 BlockType = *ImageBlock;
849
850 switch (BlockType) {
851 case EFI_HII_IIBT_IMAGE_JPEG:
852 //
853 // BUGBUG: need to be supported as soon as image tool is designed.
854 //
855 return EFI_UNSUPPORTED;
856
857 case EFI_HII_IIBT_IMAGE_1BIT_TRANS:
858 case EFI_HII_IIBT_IMAGE_4BIT_TRANS:
859 case EFI_HII_IIBT_IMAGE_8BIT_TRANS:
860 Flag = TRUE;
861 //
862 // fall through
863 //
864 case EFI_HII_IIBT_IMAGE_1BIT:
865 case EFI_HII_IIBT_IMAGE_4BIT:
866 case EFI_HII_IIBT_IMAGE_8BIT:
867 //
868 // Use the common block code since the definition of these structures is the same.
869 //
870 CopyMem (&Iibt1bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK));
871 ImageLength = sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) *
872 (Iibt1bit.Bitmap.Width * Iibt1bit.Bitmap.Height);
873 Image->Bitmap = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (ImageLength);
874 if (Image->Bitmap == NULL) {
875 return EFI_OUT_OF_RESOURCES;
876 }
877
878 if (Flag) {
879 Image->Flags = EFI_IMAGE_TRANSPARENT;
880 }
881 Image->Width = Iibt1bit.Bitmap.Width;
882 Image->Height = Iibt1bit.Bitmap.Height;
883
884 PaletteInfo = ImagePackage->PaletteBlock + sizeof (EFI_HII_IMAGE_PALETTE_INFO_HEADER);
885 for (PaletteIndex = 1; PaletteIndex < Iibt1bit.PaletteIndex; PaletteIndex++) {
886 CopyMem (&PaletteSize, PaletteInfo, sizeof (UINT16));
887 PaletteInfo += PaletteSize + sizeof (UINT16);
888 }
889 ASSERT (PaletteIndex == Iibt1bit.PaletteIndex);
890
891 //
892 // Output bitmap data
893 //
894 if (BlockType == EFI_HII_IIBT_IMAGE_1BIT || BlockType == EFI_HII_IIBT_IMAGE_1BIT_TRANS) {
895 Output1bitPixel (
896 Image,
897 (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8)),
898 (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo
899 );
900 } else if (BlockType == EFI_HII_IIBT_IMAGE_4BIT || BlockType == EFI_HII_IIBT_IMAGE_4BIT_TRANS) {
901 Output4bitPixel (
902 Image,
903 (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8)),
904 (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo
905 );
906 } else {
907 Output8bitPixel (
908 Image,
909 (UINT8 *) ((UINTN)ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8)),
910 (EFI_HII_IMAGE_PALETTE_INFO *) PaletteInfo
911 );
912 }
913
914 return EFI_SUCCESS;
915
916 case EFI_HII_IIBT_IMAGE_24BIT_TRANS:
917 Flag = TRUE;
918 //
919 // fall through
920 //
921 case EFI_HII_IIBT_IMAGE_24BIT:
922 CopyMem (&Width, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (UINT16));
923 CopyMem (
924 &Height,
925 ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT16),
926 sizeof (UINT16)
927 );
928 ImageLength = sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * (Width * Height);
929 Image->Bitmap = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (ImageLength);
930 if (Image->Bitmap == NULL) {
931 return EFI_OUT_OF_RESOURCES;
932 }
933
934 if (Flag) {
935 Image->Flags = EFI_IMAGE_TRANSPARENT;
936 }
937 Image->Width = Width;
938 Image->Height = Height;
939
940 //
941 // Output the bimap data directly.
942 //
943 Output24bitPixel (
944 Image,
945 (EFI_HII_RGB_PIXEL *) (ImageBlock + sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL))
946 );
947 return EFI_SUCCESS;
948
949 default:
950 return EFI_NOT_FOUND;
951 }
952 }
953
954
955 /**
956 This function updates the image specified by ImageId in the specified PackageListHandle to
957 the image specified by Image.
958
959 @param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
960 @param PackageList The package list containing the images.
961 @param ImageId The image's id,, which is unique within
962 PackageList.
963 @param Image Points to the image.
964
965 @retval EFI_SUCCESS The new image was updated successfully.
966 @retval EFI_NOT_FOUND The image specified by ImageId is not in the
967 database. The specified PackageList is not in the database.
968 @retval EFI_INVALID_PARAMETER The Image was NULL.
969
970 **/
971 EFI_STATUS
972 EFIAPI
973 HiiSetImage (
974 IN CONST EFI_HII_IMAGE_PROTOCOL *This,
975 IN EFI_HII_HANDLE PackageList,
976 IN EFI_IMAGE_ID ImageId,
977 IN CONST EFI_IMAGE_INPUT *Image
978 )
979 {
980 HII_DATABASE_PRIVATE_DATA *Private;
981 HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
982 HII_IMAGE_PACKAGE_INSTANCE *ImagePackage;
983 UINT8 *ImageBlock;
984 EFI_IMAGE_ID LocalImageId;
985 UINT8 BlockType;
986 EFI_HII_IIBT_IMAGE_1BIT_BLOCK Iibt1bit;
987 EFI_HII_IIBT_IMAGE_4BIT_BLOCK Iibt4bit;
988 EFI_HII_IIBT_IMAGE_8BIT_BLOCK Iibt8bit;
989 UINT16 Width;
990 UINT16 Height;
991 UINT32 BlockSize;
992 UINT32 NewBlockSize;
993 UINT32 OldBlockSize;
994 EFI_IMAGE_INPUT *ImageIn;
995 UINT8 *NewBlock;
996 UINT8 *NewBlockPtr;
997 UINT8 *Block;
998 UINT8 *BlockPtr;
999 UINT32 Part1Size;
1000 UINT32 Part2Size;
1001
1002 if (This == NULL || Image == NULL || ImageId < 1 || Image->Bitmap == NULL) {
1003 return EFI_INVALID_PARAMETER;
1004 }
1005
1006 if (!IsHiiHandleValid (PackageList)) {
1007 return EFI_NOT_FOUND;
1008 }
1009
1010 Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
1011 PackageListNode = LocatePackageList (&Private->DatabaseList, PackageList);
1012 if (PackageListNode == NULL) {
1013 return EFI_NOT_FOUND;
1014 }
1015 ImagePackage = PackageListNode->ImagePkg;
1016 if (ImagePackage == NULL) {
1017 return EFI_NOT_FOUND;
1018 }
1019
1020 //
1021 // Find the image block specified by ImageId
1022 //
1023 LocalImageId = ImageId;
1024 ImageBlock = (UINT8 *) GetImageIdOrAddress (ImagePackage->ImageBlock, &LocalImageId);
1025 if (ImageBlock == NULL) {
1026 return EFI_NOT_FOUND;
1027 }
1028
1029 BlockType = *ImageBlock;
1030
1031 //
1032 // Get the size of original image block. Use some common block code here
1033 // since the definition of some structures is the same.
1034 //
1035 switch (BlockType) {
1036 case EFI_HII_IIBT_IMAGE_JPEG:
1037 //
1038 // BUGBUG: need to be supported as soon as image tool is designed.
1039 //
1040 return EFI_UNSUPPORTED;
1041
1042 case EFI_HII_IIBT_IMAGE_1BIT:
1043 case EFI_HII_IIBT_IMAGE_1BIT_TRANS:
1044 CopyMem (&Iibt1bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK));
1045 OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_1BIT_BLOCK) - sizeof (UINT8) +
1046 BITMAP_LEN_1_BIT (Iibt1bit.Bitmap.Width, Iibt1bit.Bitmap.Height);
1047 break;
1048 case EFI_HII_IIBT_IMAGE_4BIT:
1049 case EFI_HII_IIBT_IMAGE_4BIT_TRANS:
1050 CopyMem (&Iibt4bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK));
1051 OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_4BIT_BLOCK) - sizeof (UINT8) +
1052 BITMAP_LEN_4_BIT (Iibt4bit.Bitmap.Width, Iibt4bit.Bitmap.Height);
1053 break;
1054 case EFI_HII_IIBT_IMAGE_8BIT:
1055 case EFI_HII_IIBT_IMAGE_8BIT_TRANS:
1056 CopyMem (&Iibt8bit, ImageBlock, sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK));
1057 OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_8BIT_BLOCK) - sizeof (UINT8) +
1058 BITMAP_LEN_8_BIT (Iibt8bit.Bitmap.Width, Iibt8bit.Bitmap.Height);
1059 break;
1060 case EFI_HII_IIBT_IMAGE_24BIT:
1061 case EFI_HII_IIBT_IMAGE_24BIT_TRANS:
1062 CopyMem (&Width, ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK), sizeof (UINT16));
1063 CopyMem (
1064 &Height,
1065 ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT16),
1066 sizeof (UINT16)
1067 );
1068 OldBlockSize = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +
1069 BITMAP_LEN_24_BIT (Width , Height);
1070 break;
1071 default:
1072 return EFI_NOT_FOUND;
1073 }
1074
1075 //
1076 // Create the new image block according to input image.
1077 //
1078 ImageIn = (EFI_IMAGE_INPUT *) Image;
1079 NewBlockSize = sizeof (EFI_HII_IIBT_IMAGE_24BIT_BLOCK) - sizeof (EFI_HII_RGB_PIXEL) +
1080 BITMAP_LEN_24_BIT (ImageIn->Width, ImageIn->Height);
1081 NewBlock = (UINT8 *) AllocateZeroPool (NewBlockSize);
1082 if (NewBlock == NULL) {
1083 return EFI_OUT_OF_RESOURCES;
1084 }
1085
1086 NewBlockPtr = NewBlock;
1087 if ((ImageIn->Flags & EFI_IMAGE_TRANSPARENT) == EFI_IMAGE_TRANSPARENT) {
1088 *NewBlockPtr = EFI_HII_IIBT_IMAGE_24BIT_TRANS;
1089 } else {
1090 *NewBlockPtr = EFI_HII_IIBT_IMAGE_24BIT;
1091 }
1092 NewBlockPtr++;
1093
1094 CopyMem (NewBlockPtr, &ImageIn->Width, sizeof (UINT16));
1095 NewBlockPtr += sizeof (UINT16);
1096 CopyMem (NewBlockPtr, &ImageIn->Height, sizeof (UINT16));
1097 NewBlockPtr += sizeof (UINT16);
1098
1099 CopyGopToRgbPixel ((EFI_HII_RGB_PIXEL *) NewBlockPtr, ImageIn->Bitmap, ImageIn->Width * ImageIn->Height);
1100
1101 //
1102 // Adjust the image package to remove the original block firstly then add the new block.
1103 //
1104 BlockSize = ImagePackage->ImageBlockSize + NewBlockSize - OldBlockSize;
1105 Block = (UINT8 *) AllocateZeroPool (BlockSize);
1106 if (Block == NULL) {
1107 FreePool (NewBlock);
1108 return EFI_OUT_OF_RESOURCES;
1109 }
1110
1111 BlockPtr = Block;
1112 Part1Size = (UINT32) (ImageBlock - (UINT8 *) ImagePackage->ImageBlock);
1113 Part2Size = ImagePackage->ImageBlockSize - Part1Size - OldBlockSize;
1114 CopyMem (BlockPtr, ImagePackage->ImageBlock, Part1Size);
1115 BlockPtr += Part1Size;
1116 CopyMem (BlockPtr, NewBlock, NewBlockSize);
1117 BlockPtr += NewBlockSize;
1118 CopyMem (BlockPtr, ImageBlock + OldBlockSize, Part2Size);
1119
1120 FreePool (ImagePackage->ImageBlock);
1121 FreePool (NewBlock);
1122 ImagePackage->ImageBlock = (EFI_HII_IMAGE_BLOCK *) Block;
1123 ImagePackage->ImageBlockSize = BlockSize;
1124 ImagePackage->ImagePkgHdr.Header.Length += NewBlockSize - OldBlockSize;
1125 PackageListNode->PackageListHdr.PackageLength += NewBlockSize - OldBlockSize;
1126
1127 //
1128 // Check whether need to get the contents of HiiDataBase.
1129 // Only after ReadyToBoot to do the export.
1130 //
1131 if (gExportAfterReadyToBoot) {
1132 HiiGetDatabaseInfo(&Private->HiiDatabase);
1133 }
1134
1135 return EFI_SUCCESS;
1136
1137 }
1138
1139
1140 /**
1141 This function renders an image to a bitmap or the screen using the specified
1142 color and options. It draws the image on an existing bitmap, allocates a new
1143 bitmap or uses the screen. The images can be clipped.
1144
1145 @param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
1146 @param Flags Describes how the image is to be drawn.
1147 @param Image Points to the image to be displayed.
1148 @param Blt If this points to a non-NULL on entry, this points
1149 to the image, which is Width pixels wide and
1150 Height pixels high. The image will be drawn onto
1151 this image and EFI_HII_DRAW_FLAG_CLIP is implied.
1152 If this points to a NULL on entry, then a buffer
1153 will be allocated to hold the generated image and
1154 the pointer updated on exit. It is the caller's
1155 responsibility to free this buffer.
1156 @param BltX Specifies the offset from the left and top edge of
1157 the output image of the first pixel in the image.
1158 @param BltY Specifies the offset from the left and top edge of
1159 the output image of the first pixel in the image.
1160
1161 @retval EFI_SUCCESS The image was successfully drawn.
1162 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for Blt.
1163 @retval EFI_INVALID_PARAMETER The Image or Blt was NULL.
1164 @retval EFI_INVALID_PARAMETER Any combination of Flags is invalid.
1165
1166 **/
1167 EFI_STATUS
1168 EFIAPI
1169 HiiDrawImage (
1170 IN CONST EFI_HII_IMAGE_PROTOCOL *This,
1171 IN EFI_HII_DRAW_FLAGS Flags,
1172 IN CONST EFI_IMAGE_INPUT *Image,
1173 IN OUT EFI_IMAGE_OUTPUT **Blt,
1174 IN UINTN BltX,
1175 IN UINTN BltY
1176 )
1177 {
1178 EFI_STATUS Status;
1179 HII_DATABASE_PRIVATE_DATA *Private;
1180 BOOLEAN Transparent;
1181 EFI_IMAGE_INPUT *ImageIn;
1182 EFI_IMAGE_OUTPUT *ImageOut;
1183 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
1184 UINTN BufferLen;
1185 UINTN Width;
1186 UINTN Height;
1187 UINTN Xpos;
1188 UINTN Ypos;
1189 UINTN OffsetY1;
1190 UINTN OffsetY2;
1191 EFI_FONT_DISPLAY_INFO *FontInfo;
1192 UINTN Index;
1193
1194 if (This == NULL || Image == NULL || Blt == NULL) {
1195 return EFI_INVALID_PARAMETER;
1196 }
1197
1198 if ((Flags & EFI_HII_DRAW_FLAG_CLIP) == EFI_HII_DRAW_FLAG_CLIP && *Blt == NULL) {
1199 return EFI_INVALID_PARAMETER;
1200 }
1201
1202 if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_TRANSPARENT) {
1203 return EFI_INVALID_PARAMETER;
1204 }
1205
1206 FontInfo = NULL;
1207 ImageIn = (EFI_IMAGE_INPUT *) Image;
1208
1209 //
1210 // Check whether the image will be drawn transparently or opaquely.
1211 //
1212 Transparent = FALSE;
1213 if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_TRANS) {
1214 Transparent = TRUE;
1215 } else if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_OPAQUE){
1216 Transparent = FALSE;
1217 } else {
1218 //
1219 // Now EFI_HII_DRAW_FLAG_DEFAULT is set, whether image will be drawn depending
1220 // on the image's transparency setting.
1221 //
1222 if ((ImageIn->Flags & EFI_IMAGE_TRANSPARENT) == EFI_IMAGE_TRANSPARENT) {
1223 Transparent = TRUE;
1224 }
1225 }
1226
1227 //
1228 // Image cannot be drawn transparently if Blt points to NULL on entry.
1229 // Currently output to Screen transparently is not supported, either.
1230 //
1231 if (Transparent) {
1232 if (*Blt == NULL) {
1233 return EFI_INVALID_PARAMETER;
1234 } else if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
1235 return EFI_INVALID_PARAMETER;
1236 }
1237 }
1238
1239 Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
1240
1241 //
1242 // When Blt points to a non-NULL on entry, this image will be drawn onto
1243 // this bitmap or screen pointed by "*Blt" and EFI_HII_DRAW_FLAG_CLIP is implied.
1244 // Otherwise a new bitmap will be allocated to hold this image.
1245 //
1246 if (*Blt != NULL) {
1247 //
1248 // Clip the image by (Width, Height)
1249 //
1250
1251 Width = ImageIn->Width;
1252 Height = ImageIn->Height;
1253
1254 if (Width > (*Blt)->Width - BltX) {
1255 Width = (*Blt)->Width - BltX;
1256 }
1257 if (Height > (*Blt)->Height - BltY) {
1258 Height = (*Blt)->Height - BltY;
1259 }
1260
1261 BufferLen = Width * Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1262 BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (BufferLen);
1263 if (BltBuffer == NULL) {
1264 return EFI_OUT_OF_RESOURCES;
1265 }
1266
1267 if (Width == ImageIn->Width && Height == ImageIn->Height) {
1268 CopyMem (BltBuffer, ImageIn->Bitmap, BufferLen);
1269 } else {
1270 for (Ypos = 0; Ypos < Height; Ypos++) {
1271 OffsetY1 = ImageIn->Width * Ypos;
1272 OffsetY2 = Width * Ypos;
1273 for (Xpos = 0; Xpos < Width; Xpos++) {
1274 BltBuffer[OffsetY2 + Xpos] = ImageIn->Bitmap[OffsetY1 + Xpos];
1275 }
1276 }
1277 }
1278
1279 //
1280 // Draw the image to existing bitmap or screen depending on flag.
1281 //
1282 if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
1283 //
1284 // Caller should make sure the current UGA console is grarphic mode.
1285 //
1286
1287 //
1288 // Write the image directly to the output device specified by Screen.
1289 //
1290 Status = (*Blt)->Image.Screen->Blt (
1291 (*Blt)->Image.Screen,
1292 BltBuffer,
1293 EfiBltBufferToVideo,
1294 0,
1295 0,
1296 BltX,
1297 BltY,
1298 Width,
1299 Height,
1300 0
1301 );
1302 } else {
1303 //
1304 // Draw the image onto the existing bitmap specified by Bitmap.
1305 //
1306 Status = ImageToBlt (
1307 BltBuffer,
1308 BltX,
1309 BltY,
1310 Width,
1311 Height,
1312 Transparent,
1313 Blt
1314 );
1315
1316 }
1317
1318 FreePool (BltBuffer);
1319 return Status;
1320
1321 } else {
1322 //
1323 // Allocate a new bitmap to hold the incoming image.
1324 //
1325 Width = ImageIn->Width + BltX;
1326 Height = ImageIn->Height + BltY;
1327
1328 BufferLen = Width * Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1329 BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (BufferLen);
1330 if (BltBuffer == NULL) {
1331 return EFI_OUT_OF_RESOURCES;
1332 }
1333
1334 ImageOut = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
1335 if (ImageOut == NULL) {
1336 FreePool (BltBuffer);
1337 return EFI_OUT_OF_RESOURCES;
1338 }
1339 ImageOut->Width = (UINT16) Width;
1340 ImageOut->Height = (UINT16) Height;
1341 ImageOut->Image.Bitmap = BltBuffer;
1342
1343 //
1344 // BUGBUG: Now all the "blank" pixels are filled with system default background
1345 // color. Not sure if it need to be updated or not.
1346 //
1347 Status = GetSystemFont (Private, &FontInfo, NULL);
1348 if (EFI_ERROR (Status)) {
1349 FreePool (BltBuffer);
1350 FreePool (ImageOut);
1351 return Status;
1352 }
1353 ASSERT (FontInfo != NULL);
1354 for (Index = 0; Index < Width * Height; Index++) {
1355 BltBuffer[Index] = FontInfo->BackgroundColor;
1356 }
1357 FreePool (FontInfo);
1358
1359 //
1360 // Draw the incoming image to the new created image.
1361 //
1362 *Blt = ImageOut;
1363 return ImageToBlt (
1364 ImageIn->Bitmap,
1365 BltX,
1366 BltY,
1367 ImageIn->Width,
1368 ImageIn->Height,
1369 Transparent,
1370 Blt
1371 );
1372
1373 }
1374 }
1375
1376
1377 /**
1378 This function renders an image to a bitmap or the screen using the specified
1379 color and options. It draws the image on an existing bitmap, allocates a new
1380 bitmap or uses the screen. The images can be clipped.
1381
1382 @param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
1383 @param Flags Describes how the image is to be drawn.
1384 @param PackageList The package list in the HII database to search for
1385 the specified image.
1386 @param ImageId The image's id, which is unique within
1387 PackageList.
1388 @param Blt If this points to a non-NULL on entry, this points
1389 to the image, which is Width pixels wide and
1390 Height pixels high. The image will be drawn onto
1391 this image and
1392 EFI_HII_DRAW_FLAG_CLIP is implied. If this points
1393 to a NULL on entry, then a buffer will be
1394 allocated to hold the generated image and the
1395 pointer updated on exit. It is the caller's
1396 responsibility to free this buffer.
1397 @param BltX Specifies the offset from the left and top edge of
1398 the output image of the first pixel in the image.
1399 @param BltY Specifies the offset from the left and top edge of
1400 the output image of the first pixel in the image.
1401
1402 @retval EFI_SUCCESS The image was successfully drawn.
1403 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for Blt.
1404 @retval EFI_INVALID_PARAMETER The Blt was NULL.
1405 @retval EFI_NOT_FOUND The image specified by ImageId is not in the database.
1406 The specified PackageList is not in the database.
1407
1408 **/
1409 EFI_STATUS
1410 EFIAPI
1411 HiiDrawImageId (
1412 IN CONST EFI_HII_IMAGE_PROTOCOL *This,
1413 IN EFI_HII_DRAW_FLAGS Flags,
1414 IN EFI_HII_HANDLE PackageList,
1415 IN EFI_IMAGE_ID ImageId,
1416 IN OUT EFI_IMAGE_OUTPUT **Blt,
1417 IN UINTN BltX,
1418 IN UINTN BltY
1419 )
1420 {
1421 EFI_STATUS Status;
1422 EFI_IMAGE_INPUT Image;
1423
1424 //
1425 // Check input parameter.
1426 //
1427 if (This == NULL || Blt == NULL) {
1428 return EFI_INVALID_PARAMETER;
1429 }
1430
1431 if (!IsHiiHandleValid (PackageList)) {
1432 return EFI_NOT_FOUND;
1433 }
1434
1435 //
1436 // Get the specified Image.
1437 //
1438 Status = HiiGetImage (This, PackageList, ImageId, &Image);
1439 if (EFI_ERROR (Status)) {
1440 return Status;
1441 }
1442
1443 //
1444 // Draw this image.
1445 //
1446 Status = HiiDrawImage (This, Flags, &Image, Blt, BltX, BltY);
1447 if (Image.Bitmap != NULL) {
1448 FreePool (Image.Bitmap);
1449 }
1450 return Status;
1451 }
1452
EFI Development Kit II mirror for PVE