/** @file

 Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>
 SPDX-License-Identifier: BSD-2-Clause-Patent

 **/

#include <PiDxe.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DevicePathLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>

#include <Guid/GlobalVariable.h>

#include "LcdGraphicsOutputDxe.h"

extern BOOLEAN  mDisplayInitialized;

//
// Function Definitions
//

STATIC
EFI_STATUS
VideoCopyNoHorizontalOverlap (
  IN UINTN          BitsPerPixel,
  IN volatile VOID  *FrameBufferBase,
  IN UINT32         HorizontalResolution,
  IN UINTN          SourceX,
  IN UINTN          SourceY,
  IN UINTN          DestinationX,
  IN UINTN          DestinationY,
  IN UINTN          Width,
  IN UINTN          Height
  )
{
  EFI_STATUS  Status;
  UINTN       SourceLine;
  UINTN       DestinationLine;
  UINTN       WidthInBytes;
  UINTN       LineCount;
  INTN        Step;
  VOID        *SourceAddr;
  VOID        *DestinationAddr;

  Status = EFI_SUCCESS;

  if ( DestinationY <= SourceY ) {
    // scrolling up (or horizontally but without overlap)
    SourceLine      = SourceY;
    DestinationLine = DestinationY;
    Step            = 1;
  } else {
    // scrolling down
    SourceLine      = SourceY + Height;
    DestinationLine = DestinationY + Height;
    Step            = -1;
  }

  switch (BitsPerPixel) {
    case LcdBitsPerPixel_24:

      WidthInBytes = Width * 4;

      for ( LineCount = 0; LineCount < Height; LineCount++ ) {
        // Update the start addresses of source & destination using 32bit pointer arithmetic
        SourceAddr      = (VOID *)((UINT32 *)FrameBufferBase + SourceLine      * HorizontalResolution + SourceX);
        DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX);

        // Copy the entire line Y from video ram to the temp buffer
        CopyMem (DestinationAddr, SourceAddr, WidthInBytes);

        // Update the line numbers
        SourceLine      += Step;
        DestinationLine += Step;
      }

      break;

    case LcdBitsPerPixel_16_555:
    case LcdBitsPerPixel_16_565:
    case LcdBitsPerPixel_12_444:

      WidthInBytes = Width * 2;

      for ( LineCount = 0; LineCount < Height; LineCount++ ) {
        // Update the start addresses of source & destination using 16bit pointer arithmetic
        SourceAddr      = (VOID *)((UINT16 *)FrameBufferBase + SourceLine      * HorizontalResolution + SourceX);
        DestinationAddr = (VOID *)((UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX);

        // Copy the entire line Y from video ram to the temp buffer
        CopyMem (DestinationAddr, SourceAddr, WidthInBytes);

        // Update the line numbers
        SourceLine      += Step;
        DestinationLine += Step;
      }

      break;

    case LcdBitsPerPixel_8:
    case LcdBitsPerPixel_4:
    case LcdBitsPerPixel_2:
    case LcdBitsPerPixel_1:
    default:
      // Can't handle this case
      DEBUG ((DEBUG_ERROR, "ArmVeGraphics_Blt: EfiBltVideoToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel));
      Status = EFI_INVALID_PARAMETER;
      goto EXIT;
      // break;
  }

EXIT:
  return Status;
}

STATIC
EFI_STATUS
VideoCopyHorizontalOverlap (
  IN UINTN          BitsPerPixel,
  IN volatile VOID  *FrameBufferBase,
  UINT32            HorizontalResolution,
  IN UINTN          SourceX,
  IN UINTN          SourceY,
  IN UINTN          DestinationX,
  IN UINTN          DestinationY,
  IN UINTN          Width,
  IN UINTN          Height
  )
{
  EFI_STATUS  Status;

  UINT32  *PixelBuffer32bit;
  UINT32  *SourcePixel32bit;
  UINT32  *DestinationPixel32bit;

  UINT16  *PixelBuffer16bit;
  UINT16  *SourcePixel16bit;
  UINT16  *DestinationPixel16bit;

  UINT32  SourcePixelY;
  UINT32  DestinationPixelY;
  UINTN   SizeIn32Bits;
  UINTN   SizeIn16Bits;

  Status = EFI_SUCCESS;

  switch (BitsPerPixel) {
    case LcdBitsPerPixel_24:
      // Allocate a temporary buffer

      PixelBuffer32bit = (UINT32 *)AllocatePool ((Height * Width) * sizeof (UINT32));

      if (PixelBuffer32bit == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto EXIT;
      }

      SizeIn32Bits = Width * 4;

      // Copy from the video ram (source region) to a temp buffer
      for (SourcePixelY = SourceY, DestinationPixel32bit = PixelBuffer32bit;
           SourcePixelY < SourceY + Height;
           SourcePixelY++, DestinationPixel32bit += Width)
      {
        // Update the start address of line Y (source)
        SourcePixel32bit = (UINT32 *)FrameBufferBase + SourcePixelY * HorizontalResolution + SourceX;

        // Copy the entire line Y from video ram to the temp buffer
        CopyMem ((VOID *)DestinationPixel32bit, (CONST VOID *)SourcePixel32bit, SizeIn32Bits);
      }

      // Copy from the temp buffer to the video ram (destination region)
      for (DestinationPixelY = DestinationY, SourcePixel32bit = PixelBuffer32bit;
           DestinationPixelY < DestinationY + Height;
           DestinationPixelY++, SourcePixel32bit += Width)
      {
        // Update the start address of line Y (target)
        DestinationPixel32bit = (UINT32 *)FrameBufferBase + DestinationPixelY * HorizontalResolution + DestinationX;

        // Copy the entire line Y from the temp buffer to video ram
        CopyMem ((VOID *)DestinationPixel32bit, (CONST VOID *)SourcePixel32bit, SizeIn32Bits);
      }

      // Free up the allocated memory
      FreePool ((VOID *)PixelBuffer32bit);

      break;

    case LcdBitsPerPixel_16_555:
    case LcdBitsPerPixel_16_565:
    case LcdBitsPerPixel_12_444:
      // Allocate a temporary buffer
      PixelBuffer16bit = (UINT16 *)AllocatePool ((Height * Width) * sizeof (UINT16));

      if (PixelBuffer16bit == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto EXIT;
      }

      // Access each pixel inside the source area of the Video Memory and copy it to the temp buffer

      SizeIn16Bits = Width * 2;

      for (SourcePixelY = SourceY, DestinationPixel16bit = PixelBuffer16bit;
           SourcePixelY < SourceY + Height;
           SourcePixelY++, DestinationPixel16bit += Width)
      {
        // Calculate the source address:
        SourcePixel16bit = (UINT16 *)FrameBufferBase + SourcePixelY * HorizontalResolution + SourceX;

        // Copy the entire line Y from Video to the temp buffer
        CopyMem ((VOID *)DestinationPixel16bit, (CONST VOID *)SourcePixel16bit, SizeIn16Bits);
      }

      // Copy from the temp buffer into the destination area of the Video Memory

      for (DestinationPixelY = DestinationY, SourcePixel16bit = PixelBuffer16bit;
           DestinationPixelY < DestinationY + Height;
           DestinationPixelY++, SourcePixel16bit += Width)
      {
        // Calculate the target address:
        DestinationPixel16bit = (UINT16 *)FrameBufferBase + (DestinationPixelY * HorizontalResolution + DestinationX);

        // Copy the entire line Y from the temp buffer to Video
        CopyMem ((VOID *)DestinationPixel16bit, (CONST VOID *)SourcePixel16bit, SizeIn16Bits);
      }

      // Free the allocated memory
      FreePool ((VOID *)PixelBuffer16bit);

      break;

    case LcdBitsPerPixel_8:
    case LcdBitsPerPixel_4:
    case LcdBitsPerPixel_2:
    case LcdBitsPerPixel_1:
    default:
      // Can't handle this case
      DEBUG ((DEBUG_ERROR, "ArmVeGraphics_Blt: EfiBltVideoToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel));
      Status = EFI_INVALID_PARAMETER;
      goto EXIT;
      // break;
  }

EXIT:
  return Status;
}

STATIC
EFI_STATUS
BltVideoFill (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *EfiSourcePixel      OPTIONAL,
  IN UINTN                              SourceX,
  IN UINTN                              SourceY,
  IN UINTN                              DestinationX,
  IN UINTN                              DestinationY,
  IN UINTN                              Width,
  IN UINTN                              Height,
  IN UINTN                              Delta           OPTIONAL    // Number of BYTES in a row of the BltBuffer
  )
{
  EFI_PIXEL_BITMASK  *PixelInformation;
  EFI_STATUS         Status;
  UINT32             HorizontalResolution;
  LCD_BPP            BitsPerPixel;
  VOID               *FrameBufferBase;
  VOID               *DestinationAddr;
  UINT16             *DestinationPixel16bit;
  UINT16             Pixel16bit;
  UINT32             DestinationPixelX;
  UINT32             DestinationLine;
  UINTN              WidthInBytes;

  Status               = EFI_SUCCESS;
  PixelInformation     = &This->Mode->Info->PixelInformation;
  FrameBufferBase      = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));
  HorizontalResolution = This->Mode->Info->HorizontalResolution;

  LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel);

  switch (BitsPerPixel) {
    case LcdBitsPerPixel_24:
      WidthInBytes = Width * 4;

      // Copy the SourcePixel into every pixel inside the target rectangle
      for (DestinationLine = DestinationY;
           DestinationLine < DestinationY + Height;
           DestinationLine++)
      {
        // Calculate the target address using 32bit pointer arithmetic:
        DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution  + DestinationX);

        // Fill the entire line
        SetMem32 (DestinationAddr, WidthInBytes, *((UINT32 *)EfiSourcePixel));
      }

      break;

    case LcdBitsPerPixel_16_555:
      // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel
      Pixel16bit = (UINT16)(
                            ((EfiSourcePixel->Red      <<  7) & PixelInformation->RedMask)
                            | ((EfiSourcePixel->Green    <<  2) & PixelInformation->GreenMask)
                            | ((EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask)
                            //      | ( 0                           & PixelInformation->ReservedMask )
                            );

      // Copy the SourcePixel into every pixel inside the target rectangle
      for (DestinationLine = DestinationY;
           DestinationLine < DestinationY + Height;
           DestinationLine++)
      {
        for (DestinationPixelX = DestinationX;
             DestinationPixelX < DestinationX + Width;
             DestinationPixelX++)
        {
          // Calculate the target address:
          DestinationPixel16bit =  (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX;

          // Copy the pixel into the new target
          *DestinationPixel16bit = Pixel16bit;
        }
      }

      break;

    case LcdBitsPerPixel_16_565:
      // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel
      Pixel16bit = (UINT16)(
                            ((EfiSourcePixel->Red      <<  8) & PixelInformation->RedMask)
                            | ((EfiSourcePixel->Green    <<  3) & PixelInformation->GreenMask)
                            | ((EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask)
                            );

      // Copy the SourcePixel into every pixel inside the target rectangle
      for (DestinationLine = DestinationY;
           DestinationLine < DestinationY + Height;
           DestinationLine++)
      {
        for (DestinationPixelX = DestinationX;
             DestinationPixelX < DestinationX + Width;
             DestinationPixelX++)
        {
          // Calculate the target address:
          DestinationPixel16bit =  (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution  + DestinationPixelX;

          // Copy the pixel into the new target
          *DestinationPixel16bit = Pixel16bit;
        }
      }

      break;

    case LcdBitsPerPixel_12_444:
      // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel
      Pixel16bit = (UINT16)(
                            ((EfiSourcePixel->Red      >> 4) & PixelInformation->RedMask)
                            | ((EfiSourcePixel->Green) & PixelInformation->GreenMask)
                            | ((EfiSourcePixel->Blue     << 4) & PixelInformation->BlueMask)
                            );

      // Copy the SourcePixel into every pixel inside the target rectangle
      for (DestinationLine = DestinationY;
           DestinationLine < DestinationY + Height;
           DestinationLine++)
      {
        for (DestinationPixelX = DestinationX;
             DestinationPixelX < DestinationX + Width;
             DestinationPixelX++)
        {
          // Calculate the target address:
          DestinationPixel16bit =  (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution  + DestinationPixelX;

          // Copy the pixel into the new target
          *DestinationPixel16bit = Pixel16bit;
        }
      }

      break;

    case LcdBitsPerPixel_8:
    case LcdBitsPerPixel_4:
    case LcdBitsPerPixel_2:
    case LcdBitsPerPixel_1:
    default:
      // Can't handle this case
      DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltVideoFill: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel));
      Status = EFI_INVALID_PARAMETER;
      break;
  }

  return Status;
}

STATIC
EFI_STATUS
BltVideoToBltBuffer (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BltBuffer      OPTIONAL,
  IN UINTN                              SourceX,
  IN UINTN                              SourceY,
  IN UINTN                              DestinationX,
  IN UINTN                              DestinationY,
  IN UINTN                              Width,
  IN UINTN                              Height,
  IN UINTN                              Delta           OPTIONAL    // Number of BYTES in a row of the BltBuffer
  )
{
  EFI_STATUS                     Status;
  UINT32                         HorizontalResolution;
  LCD_BPP                        BitsPerPixel;
  EFI_PIXEL_BITMASK              *PixelInformation;
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *EfiDestinationPixel;
  VOID                           *FrameBufferBase;
  VOID                           *SourceAddr;
  VOID                           *DestinationAddr;
  UINT16                         *SourcePixel16bit;
  UINT16                         Pixel16bit;
  UINT32                         SourcePixelX;
  UINT32                         SourceLine;
  UINT32                         DestinationPixelX;
  UINT32                         DestinationLine;
  UINT32                         BltBufferHorizontalResolution;
  UINTN                          WidthInBytes;

  Status               = EFI_SUCCESS;
  PixelInformation     = &This->Mode->Info->PixelInformation;
  HorizontalResolution = This->Mode->Info->HorizontalResolution;
  FrameBufferBase      = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

  if ((Delta != 0) && (Delta != Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {
    // Delta is not zero and it is different from the width.
    // Divide it by the size of a pixel to find out the buffer's horizontal resolution.
    BltBufferHorizontalResolution = (UINT32)(Delta / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
  } else {
    BltBufferHorizontalResolution = Width;
  }

  LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel);

  switch (BitsPerPixel) {
    case LcdBitsPerPixel_24:
      WidthInBytes = Width * 4;

      // Access each line inside the Video Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        // Calculate the source and target addresses using 32bit pointer arithmetic:
        SourceAddr      = (VOID *)((UINT32 *)FrameBufferBase + SourceLine      * HorizontalResolution          + SourceX);
        DestinationAddr = (VOID *)((UINT32 *)BltBuffer       + DestinationLine * BltBufferHorizontalResolution + DestinationX);

        // Copy the entire line
        CopyMem (DestinationAddr, SourceAddr, WidthInBytes);
      }

      break;

    case LcdBitsPerPixel_16_555:
      // Access each pixel inside the Video Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          SourcePixel16bit    = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX;
          EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX;

          // Snapshot the pixel from the video buffer once, to speed up the operation.
          // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations.
          Pixel16bit = *SourcePixel16bit;

          // Copy the pixel into the new target
          EfiDestinationPixel->Red   = (UINT8)((Pixel16bit & PixelInformation->RedMask) >>  7);
          EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask) >>  2);
          EfiDestinationPixel->Blue  = (UINT8)((Pixel16bit & PixelInformation->BlueMask) <<  3);
          // EfiDestinationPixel->Reserved = (UINT8) 0;
        }
      }

      break;

    case LcdBitsPerPixel_16_565:
      // Access each pixel inside the Video Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          SourcePixel16bit    = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX;
          EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX;

          // Snapshot the pixel from the video buffer once, to speed up the operation.
          // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations.
          Pixel16bit = *SourcePixel16bit;

          // Copy the pixel into the new target
          // There is no info for the Reserved byte, so we set it to zero
          EfiDestinationPixel->Red   = (UINT8)((Pixel16bit & PixelInformation->RedMask) >> 8);
          EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask) >> 3);
          EfiDestinationPixel->Blue  = (UINT8)((Pixel16bit & PixelInformation->BlueMask) << 3);
          // EfiDestinationPixel->Reserved = (UINT8) 0;
        }
      }

      break;

    case LcdBitsPerPixel_12_444:
      // Access each pixel inside the Video Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          SourcePixel16bit    = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX;
          EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX;

          // Snapshot the pixel from the video buffer once, to speed up the operation.
          // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations.
          Pixel16bit = *SourcePixel16bit;

          // Copy the pixel into the new target
          EfiDestinationPixel->Red   = (UINT8)((Pixel16bit & PixelInformation->RedMask) >> 4);
          EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask));
          EfiDestinationPixel->Blue  = (UINT8)((Pixel16bit & PixelInformation->BlueMask) << 4);
          // EfiDestinationPixel->Reserved = (UINT8) 0;
        }
      }

      break;

    case LcdBitsPerPixel_8:
    case LcdBitsPerPixel_4:
    case LcdBitsPerPixel_2:
    case LcdBitsPerPixel_1:
    default:
      // Can't handle this case
      DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltVideoToBltBuffer: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel));
      Status = EFI_INVALID_PARAMETER;
      break;
  }

  return Status;
}

STATIC
EFI_STATUS
BltBufferToVideo (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BltBuffer      OPTIONAL,
  IN UINTN                              SourceX,
  IN UINTN                              SourceY,
  IN UINTN                              DestinationX,
  IN UINTN                              DestinationY,
  IN UINTN                              Width,
  IN UINTN                              Height,
  IN UINTN                              Delta           OPTIONAL    // Number of BYTES in a row of the BltBuffer
  )
{
  EFI_STATUS                     Status;
  UINT32                         HorizontalResolution;
  LCD_BPP                        BitsPerPixel;
  EFI_PIXEL_BITMASK              *PixelInformation;
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *EfiSourcePixel;
  VOID                           *FrameBufferBase;
  VOID                           *SourceAddr;
  VOID                           *DestinationAddr;
  UINT16                         *DestinationPixel16bit;
  UINT32                         SourcePixelX;
  UINT32                         SourceLine;
  UINT32                         DestinationPixelX;
  UINT32                         DestinationLine;
  UINT32                         BltBufferHorizontalResolution;
  UINTN                          WidthInBytes;

  Status               = EFI_SUCCESS;
  PixelInformation     = &This->Mode->Info->PixelInformation;
  HorizontalResolution = This->Mode->Info->HorizontalResolution;
  FrameBufferBase      = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

  if ((Delta != 0) && (Delta != Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {
    // Delta is not zero and it is different from the width.
    // Divide it by the size of a pixel to find out the buffer's horizontal resolution.
    BltBufferHorizontalResolution = (UINT32)(Delta / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
  } else {
    BltBufferHorizontalResolution = Width;
  }

  LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel);

  switch (BitsPerPixel) {
    case LcdBitsPerPixel_24:
      WidthInBytes = Width * 4;

      // Access each pixel inside the BltBuffer Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        // Calculate the source and target addresses using 32bit pointer arithmetic:
        SourceAddr      = (VOID *)((UINT32 *)BltBuffer       + SourceLine      * BltBufferHorizontalResolution + SourceX);
        DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution          + DestinationX);

        // Copy the entire row Y
        CopyMem (DestinationAddr, SourceAddr, WidthInBytes);
      }

      break;

    case LcdBitsPerPixel_16_555:
      // Access each pixel inside the BltBuffer Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          EfiSourcePixel        = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX;
          DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX;

          // Copy the pixel into the new target
          // Only the most significant bits will be copied across:
          // To convert from 8 bits to 5 bits per pixel we throw away the 3 least significant bits
          *DestinationPixel16bit = (UINT16)(
                                            ((EfiSourcePixel->Red      <<  7) & PixelInformation->RedMask)
                                            | ((EfiSourcePixel->Green    <<  2) & PixelInformation->GreenMask)
                                            | ((EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask)
                                            //            | ( 0                                & PixelInformation->ReservedMask )
                                            );
        }
      }

      break;

    case LcdBitsPerPixel_16_565:
      // Access each pixel inside the BltBuffer Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          EfiSourcePixel        = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX;
          DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX;

          // Copy the pixel into the new target
          // Only the most significant bits will be copied across:
          // To convert from 8 bits to 5 or 6 bits per pixel we throw away the 3 or 2  least significant bits
          // There is no room for the Reserved byte so we ignore that completely
          *DestinationPixel16bit = (UINT16)(
                                            ((EfiSourcePixel->Red      <<  8) & PixelInformation->RedMask)
                                            | ((EfiSourcePixel->Green    <<  3) & PixelInformation->GreenMask)
                                            | ((EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask)
                                            );
        }
      }

      break;

    case LcdBitsPerPixel_12_444:
      // Access each pixel inside the BltBuffer Memory
      for (SourceLine = SourceY, DestinationLine = DestinationY;
           SourceLine < SourceY + Height;
           SourceLine++, DestinationLine++)
      {
        for (SourcePixelX = SourceX, DestinationPixelX = DestinationX;
             SourcePixelX < SourceX + Width;
             SourcePixelX++, DestinationPixelX++)
        {
          // Calculate the source and target addresses:
          EfiSourcePixel        = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX;
          DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX;

          // Copy the pixel into the new target
          // Only the most significant bits will be copied across:
          // To convert from 8 bits to 5 bits per pixel we throw away the 3 least significant bits
          *DestinationPixel16bit = (UINT16)(
                                            ((EfiSourcePixel->Red      << 4) & PixelInformation->RedMask)
                                            | ((EfiSourcePixel->Green) & PixelInformation->GreenMask)
                                            | ((EfiSourcePixel->Blue     >> 4) & PixelInformation->BlueMask)
                                            //            | ( 0                               & PixelInformation->ReservedMask )
                                            );
        }
      }

      break;

    case LcdBitsPerPixel_8:
    case LcdBitsPerPixel_4:
    case LcdBitsPerPixel_2:
    case LcdBitsPerPixel_1:
    default:
      // Can't handle this case
      DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltBufferToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel));
      Status = EFI_INVALID_PARAMETER;
      break;
  }

  return Status;
}

STATIC
EFI_STATUS
BltVideoToVideo (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BltBuffer      OPTIONAL,
  IN UINTN                              SourceX,
  IN UINTN                              SourceY,
  IN UINTN                              DestinationX,
  IN UINTN                              DestinationY,
  IN UINTN                              Width,
  IN UINTN                              Height,
  IN UINTN                              Delta           OPTIONAL    // Number of BYTES in a row of the BltBuffer
  )
{
  EFI_STATUS  Status;
  UINT32      HorizontalResolution;
  LCD_BPP     BitsPerPixel;
  VOID        *FrameBufferBase;

  HorizontalResolution = This->Mode->Info->HorizontalResolution;
  FrameBufferBase      = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

  //
  // BltVideo to BltVideo:
  //
  //  Source is the Video Memory,
  //  Destination is the Video Memory

  LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel);
  FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

  // The UEFI spec currently states:
  // "There is no limitation on the overlapping of the source and destination rectangles"
  // Therefore, we must be careful to avoid overwriting the source data
  if ( SourceY == DestinationY ) {
    // Copying within the same height, e.g. horizontal shift
    if ( SourceX == DestinationX ) {
      // Nothing to do
      Status = EFI_SUCCESS;
    } else if (((SourceX > DestinationX) ? (SourceX - DestinationX) : (DestinationX - SourceX)) < Width ) {
      // There is overlap
      Status = VideoCopyHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height);
    } else {
      // No overlap
      Status = VideoCopyNoHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height);
    }
  } else {
    // Copying from different heights
    Status = VideoCopyNoHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height);
  }

  return Status;
}

/***************************************
 * GraphicsOutput Protocol function, mapping to
 * EFI_GRAPHICS_OUTPUT_PROTOCOL.Blt
 *
 * PRESUMES: 1 pixel = 4 bytes (32bits)
 *  ***************************************/
EFI_STATUS
EFIAPI
LcdGraphicsBlt (
  IN EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL  *BltBuffer      OPTIONAL,
  IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION  BltOperation,
  IN UINTN                              SourceX,
  IN UINTN                              SourceY,
  IN UINTN                              DestinationX,
  IN UINTN                              DestinationY,
  IN UINTN                              Width,
  IN UINTN                              Height,
  IN UINTN                              Delta           OPTIONAL    // Number of BYTES in a row of the BltBuffer
  )
{
  EFI_STATUS    Status;
  UINT32        HorizontalResolution;
  UINT32        VerticalResolution;
  LCD_INSTANCE  *Instance;

  Instance = LCD_INSTANCE_FROM_GOP_THIS (This);

  // Setup the hardware if not already done
  if (!mDisplayInitialized) {
    Status = InitializeDisplay (Instance);
    if (EFI_ERROR (Status)) {
      goto EXIT;
    }
  }

  HorizontalResolution = This->Mode->Info->HorizontalResolution;
  VerticalResolution   = This->Mode->Info->VerticalResolution;

  // Check we have reasonable parameters
  if ((Width == 0) || (Height == 0)) {
    DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: ERROR - Invalid dimension: Zero size area.\n"));
    Status = EFI_INVALID_PARAMETER;
    goto EXIT;
  }

  if ((BltOperation == EfiBltVideoFill) || (BltOperation == EfiBltBufferToVideo) || (BltOperation == EfiBltVideoToBltBuffer)) {
    ASSERT (BltBuffer != NULL);
  }

  /*if ((DestinationX >= HorizontalResolution) || (DestinationY >= VerticalResolution)) {
    DEBUG((DEBUG_ERROR, "LcdGraphicsBlt: ERROR - Invalid destination.\n" ));
    Status = EFI_INVALID_PARAMETER;
    goto EXIT;
  }*/

  // If we are reading data out of the video buffer, check that the source area is within the display limits
  if ((BltOperation == EfiBltVideoToBltBuffer) || (BltOperation == EfiBltVideoToVideo)) {
    if ((SourceY + Height > VerticalResolution) || (SourceX + Width > HorizontalResolution)) {
      DEBUG ((DEBUG_INFO, "LcdGraphicsBlt: ERROR - Invalid source resolution.\n"));
      DEBUG ((DEBUG_INFO, "                      - SourceY=%d + Height=%d > VerticalResolution=%d.\n", SourceY, Height, VerticalResolution));
      DEBUG ((DEBUG_INFO, "                      - SourceX=%d + Width=%d > HorizontalResolution=%d.\n", SourceX, Width, HorizontalResolution));
      Status = EFI_INVALID_PARAMETER;
      goto EXIT;
    }
  }

  // If we are writing data into the video buffer, that the destination area is within the display limits
  if ((BltOperation == EfiBltVideoFill) || (BltOperation == EfiBltBufferToVideo) || (BltOperation == EfiBltVideoToVideo)) {
    if ((DestinationY + Height > VerticalResolution) || (DestinationX + Width > HorizontalResolution)) {
      DEBUG ((DEBUG_INFO, "LcdGraphicsBlt: ERROR - Invalid destination resolution.\n"));
      DEBUG ((DEBUG_INFO, "                      - DestinationY=%d + Height=%d > VerticalResolution=%d.\n", DestinationY, Height, VerticalResolution));
      DEBUG ((DEBUG_INFO, "                      - DestinationX=%d + Width=%d > HorizontalResolution=%d.\n", DestinationX, Width, HorizontalResolution));
      Status = EFI_INVALID_PARAMETER;
      goto EXIT;
    }
  }

  //
  // Perform the Block Transfer Operation
  //

  switch (BltOperation) {
    case EfiBltVideoFill:
      Status = BltVideoFill (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta);
      break;

    case EfiBltVideoToBltBuffer:
      Status = BltVideoToBltBuffer (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta);
      break;

    case EfiBltBufferToVideo:
      Status = BltBufferToVideo (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta);
      break;

    case EfiBltVideoToVideo:
      Status = BltVideoToVideo (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta);
      break;

    case EfiGraphicsOutputBltOperationMax:
    default:
      DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: Invalid Operation\n"));
      Status = EFI_INVALID_PARAMETER;
      break;
  }

EXIT:
  return Status;
}
