mirror of https://github.com/acidanthera/audk.git
273 lines
8.3 KiB
C
273 lines
8.3 KiB
C
/** @file
|
|
This library provides BMP image decoding capability.
|
|
|
|
Copyright (c) 2011 - 2015, Intel Corporation. All rights reserved.<BR>
|
|
This program and the accompanying materials are licensed and made available under
|
|
the terms and conditions of the BSD License that accompanies this distribution.
|
|
The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php.
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
#include <Uefi.h>
|
|
#include <IndustryStandard/Bmp.h>
|
|
#include <Protocol/GraphicsOutput.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/ImageDecoderLib.h>
|
|
|
|
/**
|
|
Convert a *.BMP graphics image to a callee allocated GOP blt buffer.
|
|
|
|
@param ImageFormat Format of the image file.
|
|
@param BmpImage Pointer to BMP file.
|
|
@param BmpImageSize Number of bytes in BmpImage.
|
|
@param GopBlt Buffer containing GOP version of BmpImage.
|
|
@param GopBltSize Size of GopBlt in bytes.
|
|
@param PixelWidth Width of GopBlt/BmpImage in pixels.
|
|
@param PixelHeight Height of GopBlt/BmpImage in pixels.
|
|
|
|
@retval EFI_SUCCESS GopBlt and GopBltSize are returned.
|
|
@retval EFI_INVALID_PARAMETER GopBlt or GopBltSize is NULL.
|
|
@retval EFI_UNSUPPORTED BmpImage is not a valid *.BMP image
|
|
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
BmpImageDecoderLibConvertBmpToGopBlt (
|
|
IN IMAGE_FORMAT ImageFormat,
|
|
IN UINT8 *BmpImage,
|
|
IN UINTN BmpImageSize,
|
|
OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **GopBlt,
|
|
OUT UINTN *GopBltSize,
|
|
OUT UINTN *PixelWidth,
|
|
OUT UINTN *PixelHeight
|
|
)
|
|
{
|
|
UINT8 *Image;
|
|
UINT8 *ImageHeader;
|
|
BMP_IMAGE_HEADER *BmpHeader;
|
|
BMP_COLOR_MAP *BmpColorMap;
|
|
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
|
|
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
|
|
UINT64 BltBufferSize;
|
|
UINTN Index;
|
|
UINTN Height;
|
|
UINTN Width;
|
|
UINTN ImageIndex;
|
|
UINT32 DataSizePerLine;
|
|
UINT32 ColorMapNum;
|
|
|
|
ASSERT ((GopBlt != NULL) && (GopBltSize != NULL));
|
|
|
|
if ((ImageFormat != ImageFormatBmp) && (ImageFormat != ImageFormatUnknown)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
if (sizeof (BMP_IMAGE_HEADER) > BmpImageSize) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
BmpHeader = (BMP_IMAGE_HEADER *) BmpImage;
|
|
|
|
if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Doesn't support compress.
|
|
//
|
|
if (BmpHeader->CompressionType != 0) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Only support BITMAPINFOHEADER format.
|
|
// BITMAPFILEHEADER + BITMAPINFOHEADER = BMP_IMAGE_HEADER
|
|
//
|
|
if (BmpHeader->HeaderSize != sizeof (BMP_IMAGE_HEADER) - OFFSET_OF(BMP_IMAGE_HEADER, HeaderSize)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// The data size in each line must be 4 byte alignment.
|
|
//
|
|
DataSizePerLine = ((BmpHeader->PixelWidth * BmpHeader->BitPerPixel + 31) >> 3) & (~0x3);
|
|
BltBufferSize = MultU64x32 (DataSizePerLine, BmpHeader->PixelHeight);
|
|
if (BltBufferSize > (UINT32) ~0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((BmpHeader->Size != BmpImageSize) ||
|
|
(BmpHeader->Size < BmpHeader->ImageOffset) ||
|
|
(BmpHeader->Size - BmpHeader->ImageOffset != BmpHeader->PixelHeight * DataSizePerLine)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Calculate Color Map offset in the image.
|
|
//
|
|
Image = BmpImage;
|
|
BmpColorMap = (BMP_COLOR_MAP *) (Image + sizeof (BMP_IMAGE_HEADER));
|
|
if (BmpHeader->ImageOffset < sizeof (BMP_IMAGE_HEADER)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (BmpHeader->ImageOffset > sizeof (BMP_IMAGE_HEADER)) {
|
|
switch (BmpHeader->BitPerPixel) {
|
|
case 1:
|
|
ColorMapNum = 2;
|
|
break;
|
|
case 4:
|
|
ColorMapNum = 16;
|
|
break;
|
|
case 8:
|
|
ColorMapNum = 256;
|
|
break;
|
|
default:
|
|
ColorMapNum = 0;
|
|
break;
|
|
}
|
|
//
|
|
// BMP file may has padding data between the bmp header section and the bmp data section.
|
|
//
|
|
if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) < sizeof (BMP_COLOR_MAP) * ColorMapNum) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Calculate graphics image data address in the image
|
|
//
|
|
Image = ((UINT8 *) BmpImage) + BmpHeader->ImageOffset;
|
|
ImageHeader = Image;
|
|
|
|
//
|
|
// Calculate the BltBuffer needed size.
|
|
//
|
|
BltBufferSize = MultU64x32 ((UINT64) BmpHeader->PixelWidth, BmpHeader->PixelHeight);
|
|
//
|
|
// Ensure the BltBufferSize * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) doesn't overflow
|
|
//
|
|
if (BltBufferSize > DivU64x32 ((UINTN) ~0, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
BltBufferSize = MultU64x32 (BltBufferSize, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
|
|
|
|
*GopBltSize = (UINTN) BltBufferSize;
|
|
*GopBlt = AllocatePool (*GopBltSize);
|
|
if (*GopBlt == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
*PixelWidth = BmpHeader->PixelWidth;
|
|
*PixelHeight = BmpHeader->PixelHeight;
|
|
|
|
//
|
|
// Convert image from BMP to Blt buffer format
|
|
//
|
|
BltBuffer = *GopBlt;
|
|
for (Height = 0; Height < BmpHeader->PixelHeight; Height++) {
|
|
Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth];
|
|
for (Width = 0; Width < BmpHeader->PixelWidth; Width++, Image++, Blt++) {
|
|
switch (BmpHeader->BitPerPixel) {
|
|
case 1:
|
|
//
|
|
// Convert 1-bit (2 colors) BMP to 24-bit color
|
|
//
|
|
for (Index = 0; Index < 8 && Width < BmpHeader->PixelWidth; Index++) {
|
|
Blt->Red = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Red;
|
|
Blt->Green = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Green;
|
|
Blt->Blue = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Blue;
|
|
Blt++;
|
|
Width++;
|
|
}
|
|
|
|
Blt--;
|
|
Width--;
|
|
break;
|
|
|
|
case 4:
|
|
//
|
|
// Convert 4-bit (16 colors) BMP Palette to 24-bit color
|
|
//
|
|
Index = (*Image) >> 4;
|
|
Blt->Red = BmpColorMap[Index].Red;
|
|
Blt->Green = BmpColorMap[Index].Green;
|
|
Blt->Blue = BmpColorMap[Index].Blue;
|
|
if (Width < (BmpHeader->PixelWidth - 1)) {
|
|
Blt++;
|
|
Width++;
|
|
Index = (*Image) & 0x0f;
|
|
Blt->Red = BmpColorMap[Index].Red;
|
|
Blt->Green = BmpColorMap[Index].Green;
|
|
Blt->Blue = BmpColorMap[Index].Blue;
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
//
|
|
// Convert 8-bit (256 colors) BMP Palette to 24-bit color
|
|
//
|
|
Blt->Red = BmpColorMap[*Image].Red;
|
|
Blt->Green = BmpColorMap[*Image].Green;
|
|
Blt->Blue = BmpColorMap[*Image].Blue;
|
|
break;
|
|
|
|
case 24:
|
|
//
|
|
// It is 24-bit BMP.
|
|
//
|
|
Blt->Blue = *Image++;
|
|
Blt->Green = *Image++;
|
|
Blt->Red = *Image;
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Other bit format BMP is not supported.
|
|
//
|
|
return EFI_UNSUPPORTED;
|
|
break;
|
|
};
|
|
|
|
}
|
|
|
|
ImageIndex = (UINTN) (Image - ImageHeader);
|
|
if ((ImageIndex % 4) != 0) {
|
|
//
|
|
// Bmp Image starts each row on a 32-bit boundary!
|
|
//
|
|
Image = Image + (4 - (ImageIndex % 4));
|
|
}
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Initialize BmpImageDecoderLib library.
|
|
|
|
@param ImageHandle The image handle.
|
|
@param SystemTable The system table.
|
|
|
|
@retval EFI_SUCCESS The BmpImageDecoderLib library is initialized correctly.
|
|
@return Other value if failed to initialize the BmpImageDecoderLib library.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
BmpImageDecoderLibConstructor (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
RegisterImageDecoder (BmpImageDecoderLibConvertBmpToGopBlt);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|