Image.c@ 78381

Last change on this file since 78381 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 48.3 KB

Line
1	/** @file
2	Implementation for EFI_HII_IMAGE_PROTOCOL.
3
4
5	Copyright (c) 2007 - 2014, 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 = (UINT8)((UINTN)ImageBlock + sizeof (EFI_HII_IMAGE_BLOCK) + sizeof (UINT8));
83	ImageBlock += Length8;
84	break;
85	case EFI_HII_IIBT_EXT2:
86	CopyMem (
87	&Length16,
88	(UINT8*)((UINTN)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	(UINT8*)((UINTN)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 *) ((UINTN)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 *) ((UINTN)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 *) ((UINTN)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	FontInfo = NULL;
1241	ImageIn = (EFI_IMAGE_INPUT *) Image;
1242
1243	//
1244	// Check whether the image will be drawn transparently or opaquely.
1245	//
1246	Transparent = FALSE;
1247	if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_TRANS) {
1248	Transparent = TRUE;
1249	} else if ((Flags & EFI_HII_DRAW_FLAG_TRANSPARENT) == EFI_HII_DRAW_FLAG_FORCE_OPAQUE){
1250	Transparent = FALSE;
1251	} else {
1252	//
1253	// Now EFI_HII_DRAW_FLAG_DEFAULT is set, whether image will be drawn depending
1254	// on the image's transparency setting.
1255	//
1256	if ((ImageIn->Flags & EFI_IMAGE_TRANSPARENT) == EFI_IMAGE_TRANSPARENT) {
1257	Transparent = TRUE;
1258	}
1259	}
1260
1261	//
1262	// Image cannot be drawn transparently if Blt points to NULL on entry.
1263	// Currently output to Screen transparently is not supported, either.
1264	//
1265	if (Transparent) {
1266	if (*Blt == NULL) {
1267	return EFI_INVALID_PARAMETER;
1268	} else if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
1269	return EFI_INVALID_PARAMETER;
1270	}
1271	}
1272
1273	Private = HII_IMAGE_DATABASE_PRIVATE_DATA_FROM_THIS (This);
1274
1275	//
1276	// When Blt points to a non-NULL on entry, this image will be drawn onto
1277	// this bitmap or screen pointed by "*Blt" and EFI_HII_DRAW_FLAG_CLIP is implied.
1278	// Otherwise a new bitmap will be allocated to hold this image.
1279	//
1280	if (*Blt != NULL) {
1281	//
1282	// Clip the image by (Width, Height)
1283	//
1284
1285	Width = ImageIn->Width;
1286	Height = ImageIn->Height;
1287
1288	if (Width > (*Blt)->Width - BltX) {
1289	Width = (*Blt)->Width - BltX;
1290	}
1291	if (Height > (*Blt)->Height - BltY) {
1292	Height = (*Blt)->Height - BltY;
1293	}
1294
1295	BufferLen = Width * Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1296	BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (BufferLen);
1297	if (BltBuffer == NULL) {
1298	return EFI_OUT_OF_RESOURCES;
1299	}
1300
1301	if (Width == ImageIn->Width && Height == ImageIn->Height) {
1302	CopyMem (BltBuffer, ImageIn->Bitmap, BufferLen);
1303	} else {
1304	for (Ypos = 0; Ypos < Height; Ypos++) {
1305	OffsetY1 = ImageIn->Width * Ypos;
1306	OffsetY2 = Width * Ypos;
1307	for (Xpos = 0; Xpos < Width; Xpos++) {
1308	BltBuffer[OffsetY2 + Xpos] = ImageIn->Bitmap[OffsetY1 + Xpos];
1309	}
1310	}
1311	}
1312
1313	//
1314	// Draw the image to existing bitmap or screen depending on flag.
1315	//
1316	if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
1317	//
1318	// Caller should make sure the current UGA console is grarphic mode.
1319	//
1320
1321	//
1322	// Write the image directly to the output device specified by Screen.
1323	//
1324	Status = (*Blt)->Image.Screen->Blt (
1325	(*Blt)->Image.Screen,
1326	BltBuffer,
1327	EfiBltBufferToVideo,
1328	0,
1329	0,
1330	BltX,
1331	BltY,
1332	Width,
1333	Height,
1334	0
1335	);
1336	} else {
1337	//
1338	// Draw the image onto the existing bitmap specified by Bitmap.
1339	//
1340	Status = ImageToBlt (
1341	BltBuffer,
1342	BltX,
1343	BltY,
1344	Width,
1345	Height,
1346	Transparent,
1347	Blt
1348	);
1349
1350	}
1351
1352	FreePool (BltBuffer);
1353	return Status;
1354
1355	} else {
1356	//
1357	// Allocate a new bitmap to hold the incoming image.
1358	//
1359	Width = ImageIn->Width + BltX;
1360	Height = ImageIn->Height + BltY;
1361
1362	BufferLen = Width * Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1363	BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocateZeroPool (BufferLen);
1364	if (BltBuffer == NULL) {
1365	return EFI_OUT_OF_RESOURCES;
1366	}
1367
1368	ImageOut = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
1369	if (ImageOut == NULL) {
1370	FreePool (BltBuffer);
1371	return EFI_OUT_OF_RESOURCES;
1372	}
1373	ImageOut->Width = (UINT16) Width;
1374	ImageOut->Height = (UINT16) Height;
1375	ImageOut->Image.Bitmap = BltBuffer;
1376
1377	//
1378	// BUGBUG: Now all the "blank" pixels are filled with system default background
1379	// color. Not sure if it need to be updated or not.
1380	//
1381	Status = GetSystemFont (Private, &FontInfo, NULL);
1382	if (EFI_ERROR (Status)) {
1383	FreePool (BltBuffer);
1384	FreePool (ImageOut);
1385	return Status;
1386	}
1387	ASSERT (FontInfo != NULL);
1388	for (Index = 0; Index < Width * Height; Index++) {
1389	BltBuffer[Index] = FontInfo->BackgroundColor;
1390	}
1391	FreePool (FontInfo);
1392
1393	//
1394	// Draw the incoming image to the new created image.
1395	//
1396	*Blt = ImageOut;
1397	return ImageToBlt (
1398	ImageIn->Bitmap,
1399	BltX,
1400	BltY,
1401	ImageIn->Width,
1402	ImageIn->Height,
1403	Transparent,
1404	Blt
1405	);
1406
1407	}
1408	}
1409
1410
1411	/**
1412	This function renders an image to a bitmap or the screen using the specified
1413	color and options. It draws the image on an existing bitmap, allocates a new
1414	bitmap or uses the screen. The images can be clipped.
1415
1416	@param This A pointer to the EFI_HII_IMAGE_PROTOCOL instance.
1417	@param Flags Describes how the image is to be drawn.
1418	@param PackageList The package list in the HII database to search for
1419	the specified image.
1420	@param ImageId The image's id, which is unique within
1421	PackageList.
1422	@param Blt If this points to a non-NULL on entry, this points
1423	to the image, which is Width pixels wide and
1424	Height pixels high. The image will be drawn onto
1425	this image and
1426	EFI_HII_DRAW_FLAG_CLIP is implied. If this points
1427	to a NULL on entry, then a buffer will be
1428	allocated to hold the generated image and the
1429	pointer updated on exit. It is the caller's
1430	responsibility to free this buffer.
1431	@param BltX Specifies the offset from the left and top edge of
1432	the output image of the first pixel in the image.
1433	@param BltY Specifies the offset from the left and top edge of
1434	the output image of the first pixel in the image.
1435
1436	@retval EFI_SUCCESS The image was successfully drawn.
1437	@retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for Blt.
1438	@retval EFI_INVALID_PARAMETER The Blt was NULL.
1439	@retval EFI_NOT_FOUND The image specified by ImageId is not in the database.
1440	The specified PackageList is not in the database.
1441
1442	**/
1443	EFI_STATUS
1444	EFIAPI
1445	HiiDrawImageId (
1446	IN CONST EFI_HII_IMAGE_PROTOCOL *This,
1447	IN EFI_HII_DRAW_FLAGS Flags,
1448	IN EFI_HII_HANDLE PackageList,
1449	IN EFI_IMAGE_ID ImageId,
1450	IN OUT EFI_IMAGE_OUTPUT **Blt,
1451	IN UINTN BltX,
1452	IN UINTN BltY
1453	)
1454	{
1455	EFI_STATUS Status;
1456	EFI_IMAGE_INPUT Image;
1457
1458	//
1459	// Check input parameter.
1460	//
1461	if (This == NULL \|\| Blt == NULL) {
1462	return EFI_INVALID_PARAMETER;
1463	}
1464
1465	if (!IsHiiHandleValid (PackageList)) {
1466	return EFI_NOT_FOUND;
1467	}
1468
1469	//
1470	// Get the specified Image.
1471	//
1472	Status = HiiGetImage (This, PackageList, ImageId, &Image);
1473	if (EFI_ERROR (Status)) {
1474	return Status;
1475	}
1476
1477	//
1478	// Draw this image.
1479	//
1480	Status = HiiDrawImage (This, Flags, &Image, Blt, BltX, BltY);
1481	if (Image.Bitmap != NULL) {
1482	FreePool (Image.Bitmap);
1483	}
1484	return Status;
1485	}
1486

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/HiiDatabaseDxe/Image.c@ 78381

Download in other formats: