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