]> git.proxmox.com Git - mirror_edk2.git/blob - MdePkg/Library/UefiLib/UefiLibPrint.c
Fix some typo.
[mirror_edk2.git] / MdePkg / Library / UefiLib / UefiLibPrint.c
1 /** @file
2 Mde UEFI library API implementation.
3 Print to StdErr or ConOut defined in EFI_SYSTEM_TABLE
4
5 Copyright (c) 2007 - 2008, Intel Corporation<BR>
6 All rights reserved. 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 #include "UefiLibInternal.h"
17
18 GLOBAL_REMOVE_IF_UNREFERENCED EFI_GRAPHICS_OUTPUT_BLT_PIXEL mEfiColors[16] = {
19 { 0x00, 0x00, 0x00, 0x00 },
20 { 0x98, 0x00, 0x00, 0x00 },
21 { 0x00, 0x98, 0x00, 0x00 },
22 { 0x98, 0x98, 0x00, 0x00 },
23 { 0x00, 0x00, 0x98, 0x00 },
24 { 0x98, 0x00, 0x98, 0x00 },
25 { 0x00, 0x98, 0x98, 0x00 },
26 { 0x98, 0x98, 0x98, 0x00 },
27 { 0x10, 0x10, 0x10, 0x00 },
28 { 0xff, 0x10, 0x10, 0x00 },
29 { 0x10, 0xff, 0x10, 0x00 },
30 { 0xff, 0xff, 0x10, 0x00 },
31 { 0x10, 0x10, 0xff, 0x00 },
32 { 0xf0, 0x10, 0xff, 0x00 },
33 { 0x10, 0xff, 0xff, 0x00 },
34 { 0xff, 0xff, 0xff, 0x00 }
35 };
36
37 /**
38 Internal function which prints a formatted Unicode string to the console output device
39 specified by Console
40
41 This function prints a formatted Unicode string to the console output device
42 specified by Console and returns the number of Unicode characters that printed
43 to it. If the length of the formatted Unicode string is greater than PcdUefiLibMaxPrintBufferSize,
44 then only the first PcdUefiLibMaxPrintBufferSize characters are sent to Console.
45 If Format is NULL, then ASSERT().
46 If Format is not aligned on a 16-bit boundary, then ASSERT().
47
48 @param Format Null-terminated Unicode format string.
49 @param Console The output console.
50 @param Marker VA_LIST marker for the variable argument list.
51
52 @return The number of Unicode characters in the produced
53 output buffer not including the Null-terminator.
54 **/
55 UINTN
56 InternalPrint (
57 IN CONST CHAR16 *Format,
58 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Console,
59 IN VA_LIST Marker
60 )
61 {
62 UINTN Return;
63 CHAR16 *Buffer;
64 UINTN BufferSize;
65
66 ASSERT (Format != NULL);
67 ASSERT (((UINTN) Format & BIT0) == 0);
68
69 BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
70
71 Buffer = (CHAR16 *) AllocatePool(BufferSize);
72 ASSERT (Buffer != NULL);
73
74 Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
75
76 if (Console != NULL && Return > 0) {
77 //
78 // To be extra safe make sure Console has been initialized
79 //
80 Console->OutputString (Console, Buffer);
81 }
82
83 FreePool (Buffer);
84
85 return Return;
86 }
87
88 /**
89 Prints a formatted Unicode string to the console output device specified by
90 ConOut defined in the EFI_SYSTEM_TABLE.
91
92 This function prints a formatted Unicode string to the console output device
93 specified by ConOut in EFI_SYSTEM_TABLE and returns the number of Unicode
94 characters that printed to ConOut. If the length of the formatted Unicode
95 string is greater than PcdUefiLibMaxPrintBufferSize, then only the first
96 PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
97 If Format is NULL, then ASSERT().
98 If Format is not aligned on a 16-bit boundary, then ASSERT().
99
100 @param Format Null-terminated Unicode format string.
101 @param ... Variable argument list whose contents are accessed based
102 on the format string specified by Format.
103
104 @return Number of Unicode characters printed to ConOut.
105
106 **/
107 UINTN
108 EFIAPI
109 Print (
110 IN CONST CHAR16 *Format,
111 ...
112 )
113 {
114 VA_LIST Marker;
115 UINTN Return;
116
117 VA_START (Marker, Format);
118
119 Return = InternalPrint (Format, gST->ConOut, Marker);
120
121 VA_END (Marker);
122
123 return Return;
124 }
125
126 /**
127 Prints a formatted Unicode string to the console output device specified by
128 StdErr defined in the EFI_SYSTEM_TABLE.
129
130 This function prints a formatted Unicode string to the console output device
131 specified by StdErr in EFI_SYSTEM_TABLE and returns the number of Unicode
132 characters that printed to StdErr. If the length of the formatted Unicode
133 string is greater than PcdUefiLibMaxPrintBufferSize, then only the first
134 PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
135 If Format is NULL, then ASSERT().
136 If Format is not aligned on a 16-bit boundary, then ASSERT().
137
138 @param Format Null-terminated Unicode format string.
139 @param ... Variable argument list whose contents are accessed based
140 on the format string specified by Format.
141
142 @return Number of Unicode characters printed to StdErr.
143
144 **/
145 UINTN
146 EFIAPI
147 ErrorPrint (
148 IN CONST CHAR16 *Format,
149 ...
150 )
151 {
152 VA_LIST Marker;
153 UINTN Return;
154
155 VA_START (Marker, Format);
156
157 Return = InternalPrint( Format, gST->StdErr, Marker);
158
159 VA_END (Marker);
160
161 return Return;
162 }
163
164
165 /**
166 Internal function which prints a formatted ASCII string to the console output device
167 specified by Console
168
169 This function prints a formatted ASCII string to the console output device
170 specified by Console and returns the number of ASCII characters that printed
171 to it. If the length of the formatted ASCII string is greater than PcdUefiLibMaxPrintBufferSize,
172 then only the first PcdUefiLibMaxPrintBufferSize characters are sent to Console.
173
174 If Format is NULL, then ASSERT().
175
176 @param Format Null-terminated ASCII format string.
177 @param Console The output console.
178 @param Marker VA_LIST marker for the variable argument list.
179
180 @return The number of Unicode characters in the produced
181 output buffer not including the Null-terminator.
182
183 **/
184 UINTN
185 AsciiInternalPrint (
186 IN CONST CHAR8 *Format,
187 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Console,
188 IN VA_LIST Marker
189 )
190 {
191 UINTN Return;
192 CHAR16 *Buffer;
193 UINTN BufferSize;
194
195 ASSERT (Format != NULL);
196
197 BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
198
199 Buffer = (CHAR16 *) AllocatePool(BufferSize);
200 ASSERT (Buffer != NULL);
201
202 Return = UnicodeVSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
203
204 if (Console != NULL) {
205 //
206 // To be extra safe make sure Console has been initialized
207 //
208 Console->OutputString (Console, Buffer);
209 }
210
211 FreePool (Buffer);
212
213 return Return;
214 }
215
216 /**
217 Prints a formatted ASCII string to the console output device specified by
218 ConOut defined in the EFI_SYSTEM_TABLE.
219
220 This function prints a formatted ASCII string to the console output device
221 specified by ConOut in EFI_SYSTEM_TABLE and returns the number of ASCII
222 characters that printed to ConOut. If the length of the formatted ASCII
223 string is greater than PcdUefiLibMaxPrintBufferSize, then only the first
224 PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
225 If Format is NULL, then ASSERT().
226
227 @param Format Null-terminated ASCII format string.
228 @param ... Variable argument list whose contents are accessed based
229 on the format string specified by Format.
230
231 @return Number of ASCII characters printed to ConOut.
232
233 **/
234 UINTN
235 EFIAPI
236 AsciiPrint (
237 IN CONST CHAR8 *Format,
238 ...
239 )
240 {
241 VA_LIST Marker;
242 UINTN Return;
243 ASSERT (Format != NULL);
244
245 VA_START (Marker, Format);
246
247 Return = AsciiInternalPrint( Format, gST->ConOut, Marker);
248
249 VA_END (Marker);
250
251 return Return;
252 }
253
254 /**
255 Prints a formatted ASCII string to the console output device specified by
256 StdErr defined in the EFI_SYSTEM_TABLE.
257
258 This function prints a formatted ASCII string to the console output device
259 specified by StdErr in EFI_SYSTEM_TABLE and returns the number of ASCII
260 characters that printed to StdErr. If the length of the formatted ASCII
261 string is greater than PcdUefiLibMaxPrintBufferSize, then only the first
262 PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
263 If Format is NULL, then ASSERT().
264
265 @param Format Null-terminated ASCII format string.
266 @param ... Variable argument list whose contents are accessed based
267 on the format string specified by Format.
268
269 @return Number of ASCII characters printed to ConErr.
270
271 **/
272 UINTN
273 EFIAPI
274 AsciiErrorPrint (
275 IN CONST CHAR8 *Format,
276 ...
277 )
278 {
279 VA_LIST Marker;
280 UINTN Return;
281
282 ASSERT (Format != NULL);
283
284 VA_START (Marker, Format);
285
286 Return = AsciiInternalPrint( Format, gST->StdErr, Marker);
287
288 VA_END (Marker);
289
290 return Return;
291 }
292
293 /**
294 Internal function to print a formatted Unicode string to a graphics console device specified by
295 ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
296
297 This function prints a formatted Unicode string to the graphics console device
298 specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of
299 Unicode characters printed. The EFI_HII_FONT_PROTOCOL is used to convert the
300 string to a bitmap using the glyphs registered with the
301 HII database. No wrapping is performed, so any portions of the string the fall
302 outside the active display region will not be displayed.
303
304 If a graphics console device is not associated with the ConsoleOutputHandle
305 defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
306 If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no
307 string is printed, and 0 is returned.
308
309 @param X X coordinate to print the string.
310 @param Y Y coordinate to print the string.
311 @param Foreground The forground color of the string being printed. This is
312 an optional parameter that may be NULL. If it is NULL,
313 then the foreground color of the current ConOut device
314 in the EFI_SYSTEM_TABLE is used.
315 @param Background The background color of the string being printed. This is
316 an optional parameter that may be NULL. If it is NULL,
317 then the background color of the current ConOut device
318 in the EFI_SYSTEM_TABLE is used.
319 @param Buffer Null-terminated Unicode formatted string.
320 @param PrintNum The number of Unicode formatted string to be printed.
321
322 @return Number of Unicode Characters printed. Zero means no any character
323 displayed successfully.
324
325 **/
326 UINTN
327 InternalPrintGraphic (
328 IN UINTN X,
329 IN UINTN Y,
330 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Foreground,
331 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Background,
332 IN CHAR16 *Buffer,
333 IN UINTN PrintNum
334 )
335 {
336 EFI_STATUS Status;
337 UINTN Index;
338 CHAR16 *UnicodeWeight;
339 UINT32 HorizontalResolution;
340 UINT32 VerticalResolution;
341 UINT32 ColorDepth;
342 UINT32 RefreshRate;
343 UINTN LineBufferLen;
344 EFI_HII_FONT_PROTOCOL *HiiFont;
345 EFI_IMAGE_OUTPUT *Blt;
346 EFI_FONT_DISPLAY_INFO FontInfo;
347 EFI_HII_ROW_INFO *RowInfoArray;
348 UINTN RowInfoArraySize;
349 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
350 EFI_UGA_DRAW_PROTOCOL *UgaDraw;
351 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Sto;
352 EFI_HANDLE ConsoleHandle;
353
354 HorizontalResolution = 0;
355 VerticalResolution = 0;
356 Blt = NULL;
357
358 ConsoleHandle = gST->ConsoleOutHandle;
359
360 Status = gBS->HandleProtocol (
361 ConsoleHandle,
362 &gEfiGraphicsOutputProtocolGuid,
363 (VOID **) &GraphicsOutput
364 );
365
366 UgaDraw = NULL;
367 if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
368 //
369 // If no GOP available, try to open UGA Draw protocol if supported.
370 //
371 GraphicsOutput = NULL;
372
373 Status = gBS->HandleProtocol (
374 ConsoleHandle,
375 &gEfiUgaDrawProtocolGuid,
376 (VOID **) &UgaDraw
377 );
378 }
379 if (EFI_ERROR (Status)) {
380 return 0;
381 }
382
383 Status = gBS->HandleProtocol (
384 ConsoleHandle,
385 &gEfiSimpleTextOutProtocolGuid,
386 (VOID **) &Sto
387 );
388
389 if (EFI_ERROR (Status)) {
390 return 0;
391 }
392
393 if (GraphicsOutput != NULL) {
394 HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
395 VerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
396 } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
397 UgaDraw->GetMode (UgaDraw, &HorizontalResolution, &VerticalResolution, &ColorDepth, &RefreshRate);
398 } else {
399 Status = EFI_UNSUPPORTED;
400 goto Error;
401 }
402
403 ASSERT ((HorizontalResolution != 0) && (VerticalResolution !=0));
404
405 Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **) &HiiFont);
406 if (EFI_ERROR (Status)) {
407 goto Error;
408 }
409
410 UnicodeWeight = Buffer;
411
412 for (Index = 0; UnicodeWeight[Index] != 0; Index++) {
413 if (UnicodeWeight[Index] == CHAR_BACKSPACE ||
414 UnicodeWeight[Index] == CHAR_LINEFEED ||
415 UnicodeWeight[Index] == CHAR_CARRIAGE_RETURN) {
416 UnicodeWeight[Index] = 0;
417 }
418 }
419
420 LineBufferLen = sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * HorizontalResolution * EFI_GLYPH_HEIGHT;
421 if (EFI_GLYPH_WIDTH * EFI_GLYPH_HEIGHT * sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * PrintNum > LineBufferLen) {
422 Status = EFI_INVALID_PARAMETER;
423 goto Error;
424 }
425
426 Blt = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
427 ASSERT (Blt != NULL);
428
429 Blt->Width = (UINT16) (HorizontalResolution);
430 Blt->Height = (UINT16) (VerticalResolution);
431
432 ZeroMem (&FontInfo, sizeof (EFI_FONT_DISPLAY_INFO));
433
434 if (Foreground != NULL) {
435 CopyMem (&FontInfo.ForegroundColor, Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
436 } else {
437 CopyMem (
438 &FontInfo.ForegroundColor,
439 &mEfiColors[Sto->Mode->Attribute & 0x0f],
440 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
441 );
442 }
443 if (Background != NULL) {
444 CopyMem (&FontInfo.BackgroundColor, Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
445 } else {
446 CopyMem (
447 &FontInfo.BackgroundColor,
448 &mEfiColors[Sto->Mode->Attribute >> 4],
449 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
450 );
451 }
452
453 if (GraphicsOutput != NULL) {
454 Blt->Image.Screen = GraphicsOutput;
455
456 Status = HiiFont->StringToImage (
457 HiiFont,
458 EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_DIRECT_TO_SCREEN,
459 Buffer,
460 &FontInfo,
461 &Blt,
462 X,
463 Y,
464 NULL,
465 NULL,
466 NULL
467 );
468
469 } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
470 ASSERT (UgaDraw!= NULL);
471
472 Blt->Image.Bitmap = AllocateZeroPool (Blt->Width * Blt->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
473 ASSERT (Blt->Image.Bitmap != NULL);
474
475 RowInfoArray = NULL;
476 //
477 // StringToImage only support blt'ing image to device using GOP protocol. If GOP is not supported in this platform,
478 // we ask StringToImage to print the string to blt buffer, then blt to device using UgaDraw.
479 //
480 Status = HiiFont->StringToImage (
481 HiiFont,
482 EFI_HII_IGNORE_IF_NO_GLYPH,
483 Buffer,
484 &FontInfo,
485 &Blt,
486 X,
487 Y,
488 &RowInfoArray,
489 &RowInfoArraySize,
490 NULL
491 );
492
493 if (!EFI_ERROR (Status)) {
494 ASSERT (RowInfoArray != NULL);
495 //
496 // Line breaks are handled by caller of DrawUnicodeWeightAtCursorN, so the updated parameter RowInfoArraySize by StringToImage will
497 // always be 1 or 0 (if there is no valid Unicode Char can be printed). ASSERT here to make sure.
498 //
499 ASSERT (RowInfoArraySize <= 1);
500
501 Status = UgaDraw->Blt (
502 UgaDraw,
503 (EFI_UGA_PIXEL *) Blt->Image.Bitmap,
504 EfiUgaBltBufferToVideo,
505 X,
506 Y,
507 X,
508 Y,
509 RowInfoArray[0].LineWidth,
510 RowInfoArray[0].LineHeight,
511 Blt->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
512 );
513 }
514
515 FreePool (RowInfoArray);
516 FreePool (Blt->Image.Bitmap);
517
518 } else {
519 Status = EFI_UNSUPPORTED;
520 }
521
522 FreePool (Blt);
523
524 Error:
525 if (EFI_ERROR (Status)) {
526 return 0;
527 } else {
528 return PrintNum;
529 }
530 }
531
532 /**
533 Prints a formatted Unicode string to a graphics console device specified by
534 ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
535
536 This function prints a formatted Unicode string to the graphics console device
537 specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of
538 Unicode characters printed. If the length of the formatted Unicode string is
539 greater than PcdUefiLibMaxPrintBufferSize, then only the first
540 PcdUefiLibMaxPrintBufferSize characters are printed. The EFI_HII_FONT_PROTOCOL
541 is used to convert the string to a bitmap using the glyphs registered with the
542 HII database. No wrapping is performed, so any portions of the string the fall
543 outside the active display region will not be displayed.
544
545 If a graphics console device is not associated with the ConsoleOutputHandle
546 defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
547 If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no
548 string is printed, and 0 is returned.
549 If Format is NULL, then ASSERT().
550 If Format is not aligned on a 16-bit boundary, then ASSERT().
551
552 @param X X coordinate to print the string.
553 @param Y Y coordinate to print the string.
554 @param ForeGround The foreground color of the string being printed. This is
555 an optional parameter that may be NULL. If it is NULL,
556 then the foreground color of the current ConOut device
557 in the EFI_SYSTEM_TABLE is used.
558 @param BackGround The background color of the string being printed. This is
559 an optional parameter that may be NULL. If it is NULL,
560 then the background color of the current ConOut device
561 in the EFI_SYSTEM_TABLE is used.
562 @param Format Null-terminated Unicode format string. See Print Library
563 for the supported format string syntax.
564 @param ... Variable argument list whose contents are accessed based on
565 the format string specified by Format.
566
567 @return The number of Unicode characters printed.
568
569 **/
570 UINTN
571 EFIAPI
572 PrintXY (
573 IN UINTN X,
574 IN UINTN Y,
575 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ForeGround, OPTIONAL
576 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BackGround, OPTIONAL
577 IN CONST CHAR16 *Format,
578 ...
579 )
580 {
581 VA_LIST Marker;
582 CHAR16 *Buffer;
583 UINTN BufferSize;
584 UINTN PrintNum;
585 UINTN ReturnNum;
586
587 ASSERT (Format != NULL);
588 ASSERT (((UINTN) Format & BIT0) == 0);
589
590 VA_START (Marker, Format);
591
592 BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
593
594 Buffer = (CHAR16 *) AllocatePool (BufferSize);
595 ASSERT (Buffer != NULL);
596
597 PrintNum = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
598
599 ReturnNum = InternalPrintGraphic (X, Y, ForeGround, BackGround, Buffer, PrintNum);
600
601 FreePool (Buffer);
602
603 return ReturnNum;
604 }
605
606 /**
607 Prints a formatted ASCII string to a graphics console device specified by
608 ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
609
610 This function prints a formatted ASCII string to the graphics console device
611 specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of
612 ASCII characters printed. If the length of the formatted ASCII string is
613 greater than PcdUefiLibMaxPrintBufferSize, then only the first
614 PcdUefiLibMaxPrintBufferSize characters are printed. The EFI_HII_FONT_PROTOCOL
615 is used to convert the string to a bitmap using the glyphs registered with the
616 HII database. No wrapping is performed, so any portions of the string the fall
617 outside the active display region will not be displayed.
618
619 If a graphics console device is not associated with the ConsoleOutputHandle
620 defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
621 If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no
622 string is printed, and 0 is returned.
623 If Format is NULL, then ASSERT().
624
625 @param X X coordinate to print the string.
626 @param Y Y coordinate to print the string.
627 @param ForeGround The foreground color of the string being printed. This is
628 an optional parameter that may be NULL. If it is NULL,
629 then the foreground color of the current ConOut device
630 in the EFI_SYSTEM_TABLE is used.
631 @param BackGround The background color of the string being printed. This is
632 an optional parameter that may be NULL. If it is NULL,
633 then the background color of the current ConOut device
634 in the EFI_SYSTEM_TABLE is used.
635 @param Format Null-terminated ASCII format string. See Print Library
636 for the supported format string syntax.
637 @param ... Variable argument list whose contents are accessed based on
638 the format string specified by Format.
639
640 @return The number of ASCII characters printed.
641
642 **/
643 UINTN
644 EFIAPI
645 AsciiPrintXY (
646 IN UINTN X,
647 IN UINTN Y,
648 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ForeGround, OPTIONAL
649 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BackGround, OPTIONAL
650 IN CONST CHAR8 *Format,
651 ...
652 )
653 {
654 VA_LIST Marker;
655 CHAR16 *Buffer;
656 UINTN BufferSize;
657 UINTN PrintNum;
658 UINTN ReturnNum;
659
660 ASSERT (Format != NULL);
661
662 VA_START (Marker, Format);
663
664 BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
665
666 Buffer = (CHAR16 *) AllocatePool (BufferSize);
667 ASSERT (Buffer != NULL);
668
669 PrintNum = UnicodeSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
670
671 ReturnNum = InternalPrintGraphic (X, Y, ForeGround, BackGround, Buffer, PrintNum);
672
673 FreePool (Buffer);
674
675 return ReturnNum;
676 }
677