xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Library/H2OImageDecoderLib/H2OBmpDecoder/H2OBmpDecoder.c

519 lines
15 KiB
C
Raw Blame History

/** @file
The instance of BMP Decoder Library
;******************************************************************************
;* Copyright (c) 2020, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "H2OImageDecoderLibCommon.h"
#include <IndustryStandard/Bmp.h>
#define SIZE_4G 0x100000000
//
// BMP compression type.
//
#define BMP_UNCOMPRESSION_TYPE 0
#define BMP_RLE8BIT_TYPE 1
#define BMP_RLE4BIT_TYPE 2
//
// RLE Mode.
//
#define ENCODE_MODE_END_OF_LINE 0x00
#define ENCODE_MODE_END_OF_BITMAP 0x01
#define ENCODE_MODE_DELTA 0x02
#define ABSOLUTE_MODE_FLAG 0x00
#define RGB555_TO_RGB888(color) ((color) << 3 | ((color) >> 2))
EFI_STATUS
RLE4ToBlt (
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, // Target data
UINT8 *RLE4Image, // source data
BMP_COLOR_MAP *BmpColorMap, // Palette
BMP_IMAGE_HEADER *BmpHeader //
)
{
UINT8 FirstByte;
UINT8 SecondByte;
UINTN Index;
UINTN Height;
UINTN Width;
BOOLEAN EndOfLine;
BOOLEAN EndOfBMP;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
EndOfLine = FALSE;
EndOfBMP = FALSE;
Height = 0;
while (Height <= BmpHeader->PixelHeight && EndOfBMP == FALSE) {
Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth];
Width = 0;
EndOfLine = FALSE;
while (Width <= BmpHeader->PixelWidth && EndOfLine == FALSE) {
//
// Get a WORD each time
//
FirstByte = *RLE4Image;
RLE4Image++;
SecondByte = *RLE4Image;
RLE4Image++;
if (FirstByte > ABSOLUTE_MODE_FLAG) {
UINT8 Nibble[2];
Nibble[0] = (SecondByte & 0x0F);
Nibble[1] = (SecondByte & 0xF0) >>4;
for(Index=0; Index<FirstByte; Index++, Width++, Blt++) {
//
// The left-most pixel is in the more significant nibble.
//
Blt->Red = BmpColorMap[Nibble[1-Index%2]].Red;
Blt->Green = BmpColorMap[Nibble[1-Index%2]].Green;
Blt->Blue = BmpColorMap[Nibble[1-Index%2]].Blue;
}
}
else { // FirstByte is zero...
switch (SecondByte) {
case ENCODE_MODE_END_OF_LINE:
EndOfLine = TRUE;
break;
case ENCODE_MODE_END_OF_BITMAP:
EndOfBMP = TRUE;
EndOfLine = TRUE;
break;
case ENCODE_MODE_DELTA:
FirstByte = *RLE4Image;
RLE4Image++;
SecondByte= *RLE4Image;
RLE4Image++;
Width = Width + FirstByte;
Height = Height + SecondByte;
Blt = &BltBuffer[((BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth) + (Width)];
break;
default:
//
// Absolute mode. (This block has no compression)
//
{
UINT16 ByteToBeRead = (((SecondByte-1)/4)+1)*2;
for (Index = 0; Index < ByteToBeRead; Index++) {
UINT8 NibbleHigh = ((*RLE4Image) & 0xF0) >> 4;
UINT8 NibbleLow = (*RLE4Image & 0x0F);
RLE4Image++;
if(SecondByte != 0) {
Blt->Red = BmpColorMap[NibbleHigh].Red;
Blt->Green = BmpColorMap[NibbleHigh].Green;
Blt->Blue = BmpColorMap[NibbleHigh].Blue;
Width++;
Blt++;
SecondByte--;
}
if(SecondByte != 0) {
Blt->Red = BmpColorMap[NibbleLow].Red;
Blt->Green = BmpColorMap[NibbleLow].Green;
Blt->Blue = BmpColorMap[NibbleLow].Blue;
Width++;
Blt++;
SecondByte--;
}
}
}
break;
}
}
}
Height++;
}
return EFI_SUCCESS;
}
EFI_STATUS
RLE8ToBlt (
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
UINT8 *RLE8Image,
BMP_COLOR_MAP *BmpColorMap,
BMP_IMAGE_HEADER *BmpHeader
)
{
UINT8 FirstByte;
UINT8 SecondByte;
UINT8 EachValue;
UINTN Index;
UINTN Height;
UINTN Width;
BOOLEAN EndOfLine;
BOOLEAN EndOfBMP;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
EndOfLine = FALSE;
EndOfBMP = FALSE;
Height = 0;
while (Height <= BmpHeader->PixelHeight && EndOfBMP == FALSE) {
Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth];
Width = 0;
EndOfLine = FALSE;
while (Width <= BmpHeader->PixelWidth && EndOfLine == FALSE) {
FirstByte = *RLE8Image;
RLE8Image++;
SecondByte = *RLE8Image;
RLE8Image++;
if (FirstByte > ABSOLUTE_MODE_FLAG) {
for (Index = 0; Index < FirstByte; Index++, Width++, Blt++) {
Blt->Red = BmpColorMap[SecondByte].Red;
Blt->Green = BmpColorMap[SecondByte].Green;
Blt->Blue = BmpColorMap[SecondByte].Blue;
}
}
else {
switch (SecondByte) {
case ENCODE_MODE_END_OF_LINE:
EndOfLine = TRUE;
break;
case ENCODE_MODE_END_OF_BITMAP:
EndOfBMP = TRUE;
EndOfLine = TRUE;
break;
case ENCODE_MODE_DELTA:
FirstByte = *RLE8Image;
RLE8Image++;
SecondByte= *RLE8Image;
RLE8Image++;
Width = Width + FirstByte;
Height = Height + SecondByte;
Blt = &BltBuffer[((BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth) + (Width)];
break;
default:
//
// Absolute mode.
//
for (Index = 0; Index < SecondByte; Index++, Width++, Blt++) {
EachValue = *RLE8Image;
RLE8Image++;
Blt->Red = BmpColorMap[EachValue].Red;
Blt->Green = BmpColorMap[EachValue].Green;
Blt->Blue = BmpColorMap[EachValue].Blue;
}
//
// align on word boundary
//
if (Index % 2 == 1)
RLE8Image++;
break;
}
}
}
Height++;
}
return EFI_SUCCESS;
}
/**
Convert a *.BMP graphics image to a GOP/UGA blt buffer. If a NULL Blt buffer
is passed in a GopBlt buffer will be allocated by this routine. If a GopBlt
buffer is passed in it will be used if it is big enough.
@param[in] ImageData Pointer to BMP file
@param[in] ImageDataSize Number of bytes in BMP file
@param[out] DecodedData Buffer containing GOP version of BMP file
@param[out] DecodedDataSize Size of DecodedData in bytes.
@param[out] Height Height of DecodedData/ImageData in pixels
@param[out] Width Width of DecodedData/ImageData in pixels
@retval EFI_SUCCESS GopBlt and GopBltSize are returned.
@retval EFI_UNSUPPORTED BmpImage is not a valid *.BMP image
@retval EFI_BUFFER_TOO_SMALL The passed in GopBlt buffer is not big enough.
GopBltSize will contain the required size.
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
**/
EFI_STATUS
EFIAPI
H2OHiiBmpDecode (
IN UINT8 *ImageData,
IN UINTN ImageDataSize,
OUT UINT8 **DecodedData,
OUT UINTN *DecodedDataSize,
OUT UINTN *Height,
OUT UINTN *Width
)
{
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 HeightIndex;
UINTN WidthIndex;
UINTN ImageIndex;
UINT32 DataSizePerLine;
BOOLEAN IsAllocated;
UINT32 ColorMapNum;
if (sizeof (BMP_IMAGE_HEADER) > ImageDataSize) {
return EFI_INVALID_PARAMETER;
}
BmpHeader = (BMP_IMAGE_HEADER *) ImageData;
if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') {
return EFI_UNSUPPORTED;
}
if ( BmpHeader->CompressionType != BMP_UNCOMPRESSION_TYPE
&& BmpHeader->CompressionType != BMP_RLE8BIT_TYPE
&& BmpHeader->CompressionType != BMP_RLE4BIT_TYPE ) {
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;
}
//
// Calculate Color Map offset in the image.
//
Image = ImageData;
BmpColorMap = (BMP_COLOR_MAP *) (Image + sizeof (BMP_IMAGE_HEADER));
if (BmpHeader->ImageOffset < sizeof (BMP_IMAGE_HEADER)) {
return EFI_INVALID_PARAMETER;
}
ColorMapNum = 0;
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;
}
if (BmpHeader->NumberOfColors != 0) {
ColorMapNum = BmpHeader->NumberOfColors;
}
//
// 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 *) ImageData) + 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));
if (BltBufferSize >= SIZE_4G) {
//
// The buffer size extends the limitation
//
return EFI_UNSUPPORTED;
}
IsAllocated = FALSE;
if (*DecodedData == NULL) {
*DecodedDataSize = (UINTN) BltBufferSize;
*DecodedData = H2OImageDecoderLibAllocateMem (*DecodedDataSize);
IsAllocated = TRUE;
if (*DecodedData == NULL) {
return EFI_OUT_OF_RESOURCES;
}
} else {
if (*DecodedDataSize < (UINTN) BltBufferSize) {
*DecodedDataSize = (UINTN) BltBufferSize;
return EFI_BUFFER_TOO_SMALL;
}
}
*Width = BmpHeader->PixelWidth;
*Height = BmpHeader->PixelHeight;
//
// Convert image from BMP to Blt buffer format
//
BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) *DecodedData;
//
// RLE8 decode.
//
if (BmpHeader->CompressionType == BMP_RLE8BIT_TYPE) {
SetMem (BltBuffer, (UINTN)BltBufferSize, 0x00);
RLE8ToBlt (BltBuffer, Image, BmpColorMap, BmpHeader);
return EFI_SUCCESS;
}
//
// RLE4 decode.
//
if(BmpHeader->CompressionType == BMP_RLE4BIT_TYPE) {
SetMem (BltBuffer, (UINTN)BltBufferSize, 0x00);
RLE4ToBlt (BltBuffer, Image, BmpColorMap, BmpHeader);
return EFI_SUCCESS;
}
//
// BMP decode.
//
for (HeightIndex = 0; HeightIndex < BmpHeader->PixelHeight; HeightIndex++) {
Blt = &BltBuffer[(BmpHeader->PixelHeight - HeightIndex - 1) * BmpHeader->PixelWidth];
for (WidthIndex = 0; WidthIndex < BmpHeader->PixelWidth; WidthIndex++, Image++, Blt++) {
switch (BmpHeader->BitPerPixel) {
case 1:
//
// Convert 1-bit (2 colors) BMP to 24-bit color
//
for (Index = 0; Index < 8 && WidthIndex < BmpHeader->PixelWidth; Index++) {
if ((UINT32) (((*Image) >> (7 - Index)) & 0x1) >= ColorMapNum) {
return EFI_INVALID_PARAMETER;
}
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++;
WidthIndex++;
}
Blt --;
WidthIndex --;
break;
case 4:
//
// Convert 4-bit (16 colors) BMP Palette to 24-bit color
//
Index = (*Image) >> 4;
if ((UINT32) Index >= ColorMapNum) {
return EFI_INVALID_PARAMETER;
}
Blt->Red = BmpColorMap[Index].Red;
Blt->Green = BmpColorMap[Index].Green;
Blt->Blue = BmpColorMap[Index].Blue;
if (WidthIndex < (BmpHeader->PixelWidth - 1)) {
Blt++;
WidthIndex++;
Index = (*Image) & 0x0f;
if ((UINT32) Index >= ColorMapNum) {
return EFI_INVALID_PARAMETER;
}
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
//
if ((UINT32) *Image >= ColorMapNum) {
return EFI_INVALID_PARAMETER;
}
Blt->Red = BmpColorMap[*Image].Red;
Blt->Green = BmpColorMap[*Image].Green;
Blt->Blue = BmpColorMap[*Image].Blue;
break;
case 16:
Blt->Blue = RGB555_TO_RGB888 (((*((UINT16 *) Image)) ) & 0x1F);
Blt->Green = RGB555_TO_RGB888 (((*((UINT16 *) Image)) >> 5 ) & 0x1F);
Blt->Red = RGB555_TO_RGB888 (((*((UINT16 *) Image)) >> 10) & 0x1F);
Image++;
break;
case 24:
Blt->Blue = *Image++;
Blt->Green = *Image++;
Blt->Red = *Image;
break;
case 32:
Blt->Blue = *Image++;
Blt->Green = *Image++;
Blt->Red = *Image++;
break;
default:
if (IsAllocated) {
H2OImageDecoderLibFreeMem (*DecodedData, *DecodedDataSize);
*DecodedData = NULL;
}
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;
}
Reference in New Issue View Git Blame Copy Permalink