UefiLibPrint.c

Go to the documentation of this file.

 
#include "UefiLibInternal.h"
 
GLOBAL_REMOVE_IF_UNREFERENCED EFI_GRAPHICS_OUTPUT_BLT_PIXEL  mEfiColors[16] = {
  { 0x00, 0x00, 0x00, 0x00 },
  { 0x98, 0x00, 0x00, 0x00 },
  { 0x00, 0x98, 0x00, 0x00 },
  { 0x98, 0x98, 0x00, 0x00 },
  { 0x00, 0x00, 0x98, 0x00 },
  { 0x98, 0x00, 0x98, 0x00 },
  { 0x00, 0x98, 0x98, 0x00 },
  { 0x98, 0x98, 0x98, 0x00 },
  { 0x10, 0x10, 0x10, 0x00 },
  { 0xff, 0x10, 0x10, 0x00 },
  { 0x10, 0xff, 0x10, 0x00 },
  { 0xff, 0xff, 0x10, 0x00 },
  { 0x10, 0x10, 0xff, 0x00 },
  { 0xf0, 0x10, 0xff, 0x00 },
  { 0x10, 0xff, 0xff, 0x00 },
  { 0xff, 0xff, 0xff, 0x00 }
};
 
UINTN
InternalPrint (
  IN  CONST CHAR16                     *Format,
  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Console,
  IN  VA_LIST                          Marker
  )
{
  EFI_STATUS  Status;
  UINTN       Return;
  CHAR16      *Buffer;
  UINTN       BufferSize;
 
  ASSERT (Format != NULL);
  ASSERT (((UINTN)Format & BIT0) == 0);
  ASSERT (Console != NULL);
 
  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 
  Buffer = (CHAR16 *)AllocatePool (BufferSize);
 
  if (Buffer == NULL) {
    ASSERT (Buffer != NULL);
    return 0;
  }
 
  Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
 
  if ((Console != NULL) && (Return > 0)) {
    //
    // To be extra safe make sure Console has been initialized
    //
    Status = Console->OutputString (Console, Buffer);
    if (EFI_ERROR (Status)) {
      Return = 0;
    }
  }
 
  FreePool (Buffer);
 
  return Return;
}
 
UINTN
EFIAPI
Print (
  IN CONST CHAR16  *Format,
  ...
  )
{
  VA_LIST  Marker;
  UINTN    Return;
 
  VA_START (Marker, Format);
 
  Return = InternalPrint (Format, gST->ConOut, Marker);
 
  VA_END (Marker);
 
  return Return;
}
 
UINTN
EFIAPI
ErrorPrint (
  IN CONST CHAR16  *Format,
  ...
  )
{
  VA_LIST  Marker;
  UINTN    Return;
 
  VA_START (Marker, Format);
 
  Return = InternalPrint (Format, gST->StdErr, Marker);
 
  VA_END (Marker);
 
  return Return;
}
 
UINTN
AsciiInternalPrint (
  IN  CONST CHAR8                      *Format,
  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Console,
  IN  VA_LIST                          Marker
  )
{
  EFI_STATUS  Status;
  UINTN       Return;
  CHAR16      *Buffer;
  UINTN       BufferSize;
 
  ASSERT (Format != NULL);
  ASSERT (Console != NULL);
 
  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 
  Buffer = (CHAR16 *)AllocatePool (BufferSize);
 
  if (Buffer == NULL) {
    ASSERT (Buffer != NULL);
    return 0;
  }
 
  Return = UnicodeVSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
 
  if (Console != NULL) {
    //
    // To be extra safe make sure Console has been initialized
    //
    Status = Console->OutputString (Console, Buffer);
    if (EFI_ERROR (Status)) {
      Return = 0;
    }
  }
 
  FreePool (Buffer);
 
  return Return;
}
 
UINTN
EFIAPI
AsciiPrint (
  IN CONST CHAR8  *Format,
  ...
  )
{
  VA_LIST  Marker;
  UINTN    Return;
 
  ASSERT (Format != NULL);
 
  VA_START (Marker, Format);
 
  Return = AsciiInternalPrint (Format, gST->ConOut, Marker);
 
  VA_END (Marker);
 
  return Return;
}
 
UINTN
EFIAPI
AsciiErrorPrint (
  IN CONST CHAR8  *Format,
  ...
  )
{
  VA_LIST  Marker;
  UINTN    Return;
 
  ASSERT (Format != NULL);
 
  VA_START (Marker, Format);
 
  Return = AsciiInternalPrint (Format, gST->StdErr, Marker);
 
  VA_END (Marker);
 
  return Return;
}
 
UINTN
InternalPrintGraphic (
  IN UINTN                          PointX,
  IN UINTN                          PointY,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *Foreground,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *Background,
  IN CHAR16                         *Buffer,
  IN UINTN                          PrintNum
  )
{
  EFI_STATUS                       Status;
  UINT32                           HorizontalResolution;
  UINT32                           VerticalResolution;
  UINT32                           ColorDepth;
  UINT32                           RefreshRate;
  EFI_HII_FONT_PROTOCOL            *HiiFont;
  EFI_IMAGE_OUTPUT                 *Blt;
  EFI_FONT_DISPLAY_INFO            FontInfo;
  EFI_HII_ROW_INFO                 *RowInfoArray;
  UINTN                            RowInfoArraySize;
  EFI_GRAPHICS_OUTPUT_PROTOCOL     *GraphicsOutput;
  EFI_UGA_DRAW_PROTOCOL            *UgaDraw;
  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Sto;
  EFI_HANDLE                       ConsoleHandle;
  UINTN                            Width;
  UINTN                            Height;
  UINTN                            Delta;
 
  HorizontalResolution = 0;
  VerticalResolution   = 0;
  Blt                  = NULL;
  RowInfoArray         = NULL;
 
  ConsoleHandle = gST->ConsoleOutHandle;
 
  ASSERT (ConsoleHandle != NULL);
 
  Status = gBS->HandleProtocol (
                  ConsoleHandle,
                  &gEfiGraphicsOutputProtocolGuid,
                  (VOID **)&GraphicsOutput
                  );
 
  UgaDraw = NULL;
  if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
    //
    // If no GOP available, try to open UGA Draw protocol if supported.
    //
    GraphicsOutput = NULL;
 
    Status = gBS->HandleProtocol (
                    ConsoleHandle,
                    &gEfiUgaDrawProtocolGuid,
                    (VOID **)&UgaDraw
                    );
  }
 
  if (EFI_ERROR (Status)) {
    goto Error;
  }
 
  Status = gBS->HandleProtocol (
                  ConsoleHandle,
                  &gEfiSimpleTextOutProtocolGuid,
                  (VOID **)&Sto
                  );
 
  if (EFI_ERROR (Status)) {
    goto Error;
  }
 
  if (GraphicsOutput != NULL) {
    HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
    VerticalResolution   = GraphicsOutput->Mode->Info->VerticalResolution;
  } else if ((UgaDraw != NULL) && FeaturePcdGet (PcdUgaConsumeSupport)) {
    UgaDraw->GetMode (UgaDraw, &HorizontalResolution, &VerticalResolution, &ColorDepth, &RefreshRate);
  } else {
    goto Error;
  }
 
  ASSERT ((HorizontalResolution != 0) && (VerticalResolution != 0));
 
  Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **)&HiiFont);
  if (EFI_ERROR (Status)) {
    goto Error;
  }
 
  Blt = (EFI_IMAGE_OUTPUT *)AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
 
  if (Blt == NULL) {
    ASSERT (Blt != NULL);
    goto Error;
  }
 
  Blt->Width  = (UINT16)(HorizontalResolution);
  Blt->Height = (UINT16)(VerticalResolution);
 
  ZeroMem (&FontInfo, sizeof (EFI_FONT_DISPLAY_INFO));
 
  if (Foreground != NULL) {
    CopyMem (&FontInfo.ForegroundColor, Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
  } else {
    CopyMem (
      &FontInfo.ForegroundColor,
      &mEfiColors[Sto->Mode->Attribute & 0x0f],
      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
      );
  }
 
  if (Background != NULL) {
    CopyMem (&FontInfo.BackgroundColor, Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
  } else {
    CopyMem (
      &FontInfo.BackgroundColor,
      &mEfiColors[Sto->Mode->Attribute >> 4],
      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
      );
  }
 
  if (GraphicsOutput != NULL) {
    Blt->Image.Screen = GraphicsOutput;
 
    Status = HiiFont->StringToImage (
                        HiiFont,
                        EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_OUT_FLAG_CLIP |
                        EFI_HII_OUT_FLAG_CLIP_CLEAN_X | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y |
                        EFI_HII_IGNORE_LINE_BREAK | EFI_HII_DIRECT_TO_SCREEN,
                        Buffer,
                        &FontInfo,
                        &Blt,
                        PointX,
                        PointY,
                        &RowInfoArray,
                        &RowInfoArraySize,
                        NULL
                        );
    if (EFI_ERROR (Status)) {
      goto Error;
    }
  } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
    ASSERT (UgaDraw != NULL);
 
    //
    // Ensure Width * Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) doesn't overflow.
    //
    if (Blt->Width > DivU64x32 (MAX_UINTN, Blt->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {
      goto Error;
    }
 
    Blt->Image.Bitmap = AllocateZeroPool ((UINT32)Blt->Width * Blt->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
    ASSERT (Blt->Image.Bitmap != NULL);
 
    //
    //  StringToImage only support blt'ing image to device using GOP protocol. If GOP is not supported in this platform,
    //  we ask StringToImage to print the string to blt buffer, then blt to device using UgaDraw.
    //
    Status = HiiFont->StringToImage (
                        HiiFont,
                        EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_OUT_FLAG_CLIP |
                        EFI_HII_OUT_FLAG_CLIP_CLEAN_X | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y |
                        EFI_HII_IGNORE_LINE_BREAK,
                        Buffer,
                        &FontInfo,
                        &Blt,
                        PointX,
                        PointY,
                        &RowInfoArray,
                        &RowInfoArraySize,
                        NULL
                        );
 
    if (!EFI_ERROR (Status)) {
      ASSERT (RowInfoArray != NULL);
      //
      // Explicit Line break characters are ignored, so the updated parameter RowInfoArraySize by StringToImage will
      // always be 1 or 0 (if there is no valid Unicode Char can be printed). ASSERT here to make sure.
      //
      ASSERT (RowInfoArraySize <= 1);
 
      if (RowInfoArraySize != 0) {
        Width  = RowInfoArray[0].LineWidth;
        Height = RowInfoArray[0].LineHeight;
        Delta  = Blt->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
      } else {
        Width  = 0;
        Height = 0;
        Delta  = 0;
      }
 
      Status = UgaDraw->Blt (
                          UgaDraw,
                          (EFI_UGA_PIXEL *)Blt->Image.Bitmap,
                          EfiUgaBltBufferToVideo,
                          PointX,
                          PointY,
                          PointX,
                          PointY,
                          Width,
                          Height,
                          Delta
                          );
    } else {
      goto Error;
    }
 
    FreePool (Blt->Image.Bitmap);
  } else {
    goto Error;
  }
 
  //
  // Calculate the number of actual printed characters
  //
  if (RowInfoArraySize != 0) {
    PrintNum = RowInfoArray[0].EndIndex - RowInfoArray[0].StartIndex + 1;
  } else {
    PrintNum = 0;
  }
 
  FreePool (RowInfoArray);
  FreePool (Blt);
  return PrintNum;
 
Error:
  if (Blt != NULL) {
    FreePool (Blt);
  }
 
  return 0;
}
 
UINTN
EFIAPI
PrintXY (
  IN UINTN                          PointX,
  IN UINTN                          PointY,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *ForeGround  OPTIONAL,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BackGround  OPTIONAL,
  IN CONST CHAR16                   *Format,
  ...
  )
{
  VA_LIST  Marker;
  CHAR16   *Buffer;
  UINTN    BufferSize;
  UINTN    PrintNum;
  UINTN    ReturnNum;
 
  ASSERT (Format != NULL);
  ASSERT (((UINTN)Format & BIT0) == 0);
 
  VA_START (Marker, Format);
 
  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 
  Buffer = (CHAR16 *)AllocatePool (BufferSize);
 
  if (Buffer == NULL) {
    ASSERT (Buffer != NULL);
    return 0;
  }
 
  PrintNum = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
 
  VA_END (Marker);
 
  ReturnNum = InternalPrintGraphic (PointX, PointY, ForeGround, BackGround, Buffer, PrintNum);
 
  FreePool (Buffer);
 
  return ReturnNum;
}
 
UINTN
EFIAPI
AsciiPrintXY (
  IN UINTN                          PointX,
  IN UINTN                          PointY,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *ForeGround  OPTIONAL,
  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BackGround  OPTIONAL,
  IN CONST CHAR8                    *Format,
  ...
  )
{
  VA_LIST  Marker;
  CHAR16   *Buffer;
  UINTN    BufferSize;
  UINTN    PrintNum;
  UINTN    ReturnNum;
 
  ASSERT (Format != NULL);
 
  VA_START (Marker, Format);
 
  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 
  Buffer = (CHAR16 *)AllocatePool (BufferSize);
 
  if (Buffer == NULL) {
    ASSERT (Buffer != NULL);
    return 0;
  }
 
  PrintNum = UnicodeSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
 
  VA_END (Marker);
 
  ReturnNum = InternalPrintGraphic (PointX, PointY, ForeGround, BackGround, Buffer, PrintNum);
 
  FreePool (Buffer);
 
  return ReturnNum;
}
 
CHAR16 *
EFIAPI
CatVSPrint (
  IN  CHAR16        *String  OPTIONAL,
  IN  CONST CHAR16  *FormatString,
  IN  VA_LIST       Marker
  )
{
  UINTN    CharactersRequired;
  UINTN    SizeRequired;
  CHAR16   *BufferToReturn;
  VA_LIST  ExtraMarker;
 
  VA_COPY (ExtraMarker, Marker);
  CharactersRequired = SPrintLength (FormatString, ExtraMarker);
  VA_END (ExtraMarker);
 
  if (String != NULL) {
    SizeRequired = StrSize (String) + (CharactersRequired * sizeof (CHAR16));
  } else {
    SizeRequired = sizeof (CHAR16) + (CharactersRequired * sizeof (CHAR16));
  }
 
  BufferToReturn = AllocatePool (SizeRequired);
 
  if (BufferToReturn == NULL) {
    return NULL;
  } else {
    BufferToReturn[0] = L'\0';
  }
 
  if (String != NULL) {
    StrCpyS (BufferToReturn, SizeRequired / sizeof (CHAR16), String);
  }
 
  UnicodeVSPrint (BufferToReturn + StrLen (BufferToReturn), (CharactersRequired+1) * sizeof (CHAR16), FormatString, Marker);
 
  ASSERT (StrSize (BufferToReturn) == SizeRequired);
 
  return (BufferToReturn);
}
 
CHAR16 *
EFIAPI
CatSPrint (
  IN  CHAR16        *String  OPTIONAL,
  IN  CONST CHAR16  *FormatString,
  ...
  )
{
  VA_LIST  Marker;
  CHAR16   *NewString;
 
  VA_START (Marker, FormatString);
  NewString = CatVSPrint (String, FormatString, Marker);
  VA_END (Marker);
  return NewString;
}