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

685 lines
16 KiB
C
Raw Permalink Blame History

/** @file
Gif Converter application to covert Gif file to HII animation binary
;******************************************************************************
;* 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 "Gif.h"
#include <Library/DebugLib.h>
STATIC
EFI_STATUS
RetrieveCompressedData (
IN UINT8 **GifFileImage,
IN UINTN *GifFileSize,
IN UINT8 *CompressedData,
IN OUT UINTN *CompressedDataSize
);
STATIC
UINT16
GetCode (
IN UINT8 *BufIn,
IN UINT8 CodeSize,
OUT UINT32 *WhichBit
);
STATIC
UINT32
LZWDecoder (
IN UINT8 *BufIn,
IN UINTN BufInSize,
IN BOOLEAN Interlaced,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ColorMap,
IN UINT16 Width,
IN UINT16 Height,
IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ImageData
);
/**
Read data safely
@param [in, out] FileImage Pointer to file image buffer
@param [in, out] FileSize Pointer to file image size
@param [out] Buffer Pointer to read buffer
@param [in] ReadSize Size of read data
@retval TRUE Read data success
@retval FALSE No data to read
**/
STATIC
BOOLEAN
ReadOk (
IN OUT UINT8 **FileImage,
IN OUT UINTN *FileSize,
OUT VOID *Buffer,
IN UINT32 ReadSize
)
{
if (*FileSize < ReadSize) {
return FALSE;
}
CopyMem (Buffer, *FileImage, ReadSize);
*FileImage += ReadSize;
*FileSize -= ReadSize;
return TRUE;
}
/**
Get data block, 1 byte block size and n byte data
@param [in, out] GifFileImage Pointer to file image
@param [in, out] GifFileSize Pointer to file image size
@param [out] Buffer Pointer to read data
@retval 0 No data to read
@return others Read data size
**/
STATIC
UINT32
GetDataBlock (
IN OUT UINT8 **GifFileImage,
IN OUT UINTN *GifFileSize,
OUT UINT8 *Buffer
)
{
UINT8 BlockSize;
if (!ReadOk (GifFileImage, GifFileSize, &BlockSize, 1)) {
return 0;
}
if ((BlockSize != 0) && (!ReadOk(GifFileImage, GifFileSize, Buffer, BlockSize))) {
return 0;
}
return BlockSize;
}
/**
Get gif logical screen, include gif image information and color map
@param [in, out] FileImage Pointer to file image
@param [in, out] FileSize Pointer to file image size
@param [out] GifScreen Gif image information
@param [out] GlobalColorMap Global color map for gif imgae
@retval EFI_SUCCESS read success
@retval EFI_UNSUPPORTED format error
@retval EFI_INVALID_PARAMETER Invalid parameter
**/
EFI_STATUS
GifDecoderGetLogicalScreen (
IN OUT UINT8 **FileImage,
IN OUT UINTN *FileSize,
OUT GIF_LOGICAL_SCREEN_DESCRIPTOR *GifScreen,
OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *GlobalColorMap
)
{
UINT8 *ColorPtr;
GIF_HEADER GifHeader;
UINT32 MapSize;
UINT16 Index;
ASSERT (FileImage != NULL && *FileImage != NULL && FileSize != NULL);
if ((FileImage == NULL) || (*FileImage == NULL) || (FileSize == NULL)) {
return EFI_INVALID_PARAMETER;
}
ASSERT (GifScreen != NULL && GlobalColorMap != NULL);
if ((GifScreen == NULL) || (GlobalColorMap == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Gif Header
//
if ((!ReadOk (FileImage, FileSize, &GifHeader, sizeof(GIF_HEADER))) ||
(CompareMem (&GifHeader, "GIF87a", sizeof (GIF_HEADER)) != 0 &&
CompareMem (&GifHeader, "GIF89a", sizeof (GIF_HEADER)) != 0)) {
return EFI_UNSUPPORTED;
}
//
// Gif Logical Screen Descriptor
//
if (!ReadOk (FileImage, FileSize, GifScreen, sizeof (GIF_LOGICAL_SCREEN_DESCRIPTOR))) {
return EFI_UNSUPPORTED;
}
//
// Gif Global Color Map
//
MapSize = 1 << (GifScreen->PackedFields.SizeOfGlobalColorTable + 1);
if (GifScreen->PackedFields.GlobalColorTableFlag) {
if (*FileSize < (UINT32)(MapSize * 3)) {
return EFI_UNSUPPORTED;
}
ColorPtr = *FileImage;
for (Index = 0; Index < MapSize; ++Index) {
GlobalColorMap[Index].Red = *ColorPtr;
GlobalColorMap[Index].Green = *(ColorPtr + 1);
GlobalColorMap[Index].Blue = *(ColorPtr + 2);
GlobalColorMap[Index].Reserved = 0;
ColorPtr += 3;
}
*FileImage += MapSize * 3;
*FileSize -= MapSize * 3;
} else {
for (Index = 0; Index < MapSize; ++Index) {
GlobalColorMap[Index].Red = (UINT8)Index;
GlobalColorMap[Index].Green = (UINT8)Index;
GlobalColorMap[Index].Blue = (UINT8)Index;
GlobalColorMap[Index].Reserved = 0;
}
}
return EFI_SUCCESS;
}
/**
Get single image description (offset x, y), local color map,
and graphic control (delay time, and transparent)
@retval EFI_SUCCESS read success, has one signle image
@retval EFI_NOT_FOUND no image to read
@retval EFI_UNSUPPORTED format error
@retval EFI_INVALID_PARAMETER Invalid parameter.
**/
EFI_STATUS
GifDecoderGetImageDesc (
IN UINT8 **GifFileImage,
IN UINTN *GifFileSize,
OUT GIF_IMAGE_DESCRIPTOR *ImageDesc,
OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LocalColorMap,
OUT GIF_GRAPHIC_CONTROL_EXTENSION *GraphicControl
)
{
UINT8 Ch;
UINT8 Label;
UINT8 Buf[256];
UINT32 Count;
UINT8 *ColorPtr;
UINT8 *ImagePtr;
UINTN FileSize;
UINT32 MapSize;
UINT32 Index;
ASSERT (GifFileImage != NULL);
if (GifFileImage == NULL) {
return EFI_INVALID_PARAMETER;
}
ImagePtr = *GifFileImage;
FileSize = *GifFileSize;
if (FileSize == 0) {
return EFI_NOT_FOUND;
}
Ch = *ImagePtr;
while (Ch != GIF_TRAILER) {
if (Ch == IMAGE_SEPARATOR) {
if (!ReadOk (&ImagePtr, &FileSize, ImageDesc, sizeof (GIF_IMAGE_DESCRIPTOR))) {
return EFI_UNSUPPORTED;
}
if (ImageDesc->PackedFields.LocalColorTableFlag) {
MapSize = 1 << (ImageDesc->PackedFields.SizeOfLocalColorTable + 1);
if (FileSize < (UINT32)(MapSize * 3)) {
return EFI_UNSUPPORTED;
}
ColorPtr = ImagePtr;
for (Index = 0; Index < MapSize; ++Index) {
LocalColorMap[Index].Red = *ColorPtr;
LocalColorMap[Index].Green = *(ColorPtr + 1);
LocalColorMap[Index].Blue = *(ColorPtr + 2);
LocalColorMap[Index].Reserved = 0;
ColorPtr += 3;
}
ImagePtr += MapSize * 3;
FileSize -= MapSize * 3;
}
*GifFileImage = ImagePtr;
*GifFileSize = FileSize;
return EFI_SUCCESS;
} else if (Ch == EXTENSION_INTRODUCER) {
if (FileSize < 2) {
return EFI_UNSUPPORTED;
}
Label = *(ImagePtr + 1);
ImagePtr += 2;
FileSize -= 2;
if (Label == GRAPHIC_CONTROL_LABEL) {
Count = GetDataBlock (&ImagePtr, &FileSize, Buf);
if (Count != 4) {
return EFI_UNSUPPORTED;
} else {
CopyMem (&GraphicControl->PackedFields, Buf, 4);
while (GetDataBlock (&ImagePtr, &FileSize, Buf) != 0);
}
} else {
while (GetDataBlock (&ImagePtr, &FileSize, Buf) != 0);
}
} else {
ImagePtr++;
FileSize--;
}
if (FileSize == 0) {
return EFI_UNSUPPORTED;
} else {
Ch = *ImagePtr;
}
}
*GifFileImage = ImagePtr;
*GifFileSize = FileSize;
return EFI_NOT_FOUND;
}
/**
Decompress LZW data to graphics output pixel format image data
@param [in] GifFileImage Pointer to file imag
@param [in] GifFileSize Pointer to file image size
@param [in] ImageDesc Gif image description
@param [in] GlobalColorMap Global color map
@param [in] LocalColorMap Local color map
@param [in] GraphicControl
@param [out] ImageData Graphics Output Pixel format image data
@param [in] ImageSize
@param [in] CompressedData Temporary buffer for fragmentary image data block
@param [in, out] CompressedDataSize Temporary buffer size
@retval EFI_SUCCESS read success, has one signle image
@retval EFI_BUFFER_TOO_SMALL buffer too small
@retval EFI_UNSUPPORTED format error
**/
EFI_STATUS
GifDecoderGetImageData (
IN UINT8 **GifFileImage,
IN UINTN *GifFileSize,
IN GIF_IMAGE_DESCRIPTOR *ImageDesc,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *GlobalColorMap,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LocalColorMap,
IN GIF_GRAPHIC_CONTROL_EXTENSION *GraphicControl,
OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ImageData,
IN UINT32 ImageSize,
IN UINT8 *CompressedData,
IN OUT UINTN *CompressedDataSize
)
{
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ColorMap;
UINT8 *ImagePtr;
UINTN FileSize;
//
// allocate compressed data
//
ImagePtr = *GifFileImage;
FileSize = *GifFileSize;
Status = RetrieveCompressedData (
&ImagePtr,
&FileSize,
CompressedData,
CompressedDataSize
);
if (EFI_ERROR (Status)) {
return Status;
}
*GifFileImage = ImagePtr;
*GifFileSize = FileSize;
if (ImageDesc->PackedFields.LocalColorTableFlag) {
ColorMap = LocalColorMap;
} else {
ColorMap = GlobalColorMap;
}
LZWDecoder (
CompressedData,
*CompressedDataSize,
ImageDesc->PackedFields.InterlaceFlag,
ColorMap,
ImageDesc->ImageWidth,
ImageDesc->ImageHeight,
ImageData
);
return EFI_SUCCESS;
}
/**
Convert fragmentary image data block to a continuous block
@param [in] GifFileImage Pointer to file imag
@param [in] GifFileSize Pointer to file image size
@param [in] CompressedData Temporary buffer for fragmentary image data block
@param [in, out] CompressedDataSize Temporary buffer size
@retval EFI_SUCCESS read success, has one signle image
@retval EFI_BUFFER_TOO_SMALL buffer too small
@retval EFI_UNSUPPORTED format error
**/
EFI_STATUS
RetrieveCompressedData (
IN UINT8 **GifFileImage,
IN UINTN *GifFileSize,
IN UINT8 *CompressedData,
IN OUT UINTN *CompressedDataSize
)
{
UINT8 LzwCodeSize;
UINT8 BlockLength;
UINTN TotalSize;
UINTN AvailableSize;
UINT8 Buf[256];
UINT8 *ImagePtr;
UINTN FileSize;
ImagePtr = *GifFileImage;
FileSize = *GifFileSize;
AvailableSize = *CompressedDataSize;
//
// calculate lzwcodesize compressed data size, then copy data
//
if (!ReadOk (&ImagePtr, &FileSize, &LzwCodeSize, 1)) {
return EFI_UNSUPPORTED;
}
TotalSize = 1;
if (AvailableSize >= 1) {
*CompressedData = LzwCodeSize;
AvailableSize -= 1;
}
for (;;) {
if (!ReadOk (&ImagePtr, &FileSize, &BlockLength, 1)) {
return EFI_UNSUPPORTED;
}
if ((BlockLength == 0) || (AvailableSize < BlockLength)) {
break;
}
if (!ReadOk (&ImagePtr, &FileSize, CompressedData + TotalSize, BlockLength)) {
return EFI_UNSUPPORTED;
}
AvailableSize -= BlockLength;
TotalSize += BlockLength;
}
if (BlockLength != 0) {
do {
if (!ReadOk (&ImagePtr, &FileSize, Buf, BlockLength)) {
return EFI_UNSUPPORTED;
}
TotalSize += BlockLength;
if (!ReadOk (&ImagePtr, &FileSize, &BlockLength, 1)) {
return EFI_UNSUPPORTED;
}
} while (BlockLength != 0);
}
if (*CompressedDataSize < TotalSize) {
*CompressedDataSize = TotalSize;
return EFI_BUFFER_TOO_SMALL;
}
*CompressedDataSize = TotalSize;
*GifFileImage = ImagePtr;
*GifFileSize = FileSize;
return EFI_SUCCESS;
}
/**
Get code data by code size
@param [in] BufIn Buffer to read
@param [in] CodeSize Size (bits) of Read
@param [out] WhichBit Record already read bits
@retval Data read data
**/
STATIC
UINT16
GetCode (
IN UINT8 *BufIn,
IN UINT8 CodeSize,
OUT UINT32 *WhichBit
)
{
UINT32 Bit;
UINT32 Data;
Bit = *WhichBit;
Data = *(UINT32 *) (BufIn + Bit / 8);
Data >>= (Bit & 7);
Data = Data & ((1 << CodeSize) - 1);
*WhichBit += CodeSize;
return (UINT16)Data;
}
/**
LZW decoder
@param [in] BufIn Pointer to compressed data
@param [in] BufInSize Pointer to compressed data size
@param [in] Interlaced Data store is interlaced
@param [in] ColorMap Image color map
@param [in] Width Image width
@param [in] Height Image Height
@param [in, out] Blt Output image data
@return ReadBits Read image bits
**/
STATIC
UINT32
LZWDecoder (
IN UINT8 *BufIn,
IN UINTN BufInSize,
IN BOOLEAN Interlaced,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ColorMap,
IN UINT16 Width,
IN UINT16 Height,
IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt
)
{
UINT16 PrevCode;
UINT16 Code;
UINT16 ClearCode;
UINT16 EndCode;
UINT16 TmpCode;
UINT8 InitCodeSize;
UINT8 CodeSize;
UINT16 FirstIndex;
UINT16 EntryIndex;
UINT32 ReadBits;
INTN OutIndex;
UINT16 Index;
INT16 StackIndex;
UINT16 X;
UINT16 Y;
InitCodeSize = *BufIn;
BufIn++;
CodeSize = InitCodeSize + 1;
ClearCode = (1 << InitCodeSize);
EndCode = ClearCode + 1;
FirstIndex = EndCode + 1;
EntryIndex = FirstIndex;
ReadBits = 0;
OutIndex = 0;
PrevCode = NONCODE;
X = 0;
Y = 0;
//
// init lzw table
//
for (Index = 0; Index < ClearCode; ++Index) {
mLzwTable[Index].Prefix = NONCODE;
mLzwTable[Index].Suffix = (UINT8)Index;
}
for (;;) {
if (((ReadBits + CodeSize) / 8) > BufInSize) {
//
// no data
//
//Print (L"nodata");
break;
} else {
Code = GetCode (BufIn, CodeSize, &ReadBits);
}
if (Code == EndCode) {
break;
}
if (Code == ClearCode) {
CodeSize = InitCodeSize + 1;
EntryIndex = FirstIndex;
PrevCode = ClearCode;
} else {
if (Y == Height) {
//Print (L"bad code");
break;
}
StackIndex = -1;
if (Code < EntryIndex) {
//
// code in table
// convert [code] to string, and output [code]
// add new entry [prevcode][first char of code]
//
TmpCode = Code;
while (TmpCode != NONCODE) {
mOutStack[++StackIndex] = mLzwTable[TmpCode].Suffix;
TmpCode = mLzwTable[TmpCode].Prefix;
}
} else {
if (PrevCode == ClearCode) {
//Print (L"bad code");
continue;
}
//
// code isn't in table
// convert [prevcode] to string, and output [prevcode][first char of prevcode]
// add new entry [prevcode][first char of prevcode]
//
StackIndex++;
TmpCode = PrevCode;
while (TmpCode != NONCODE) {
mOutStack[++StackIndex] = mLzwTable[TmpCode].Suffix;
TmpCode = mLzwTable[TmpCode].Prefix;
}
mOutStack[0] = mOutStack[StackIndex];
}
if (PrevCode != ClearCode) {
mLzwTable[EntryIndex].Prefix = PrevCode;
mLzwTable[EntryIndex].Suffix = mOutStack[StackIndex];
EntryIndex++;
}
//
// output outstack data
//
while (StackIndex >= 0) {
Blt[X + Y * Width] = ColorMap[mOutStack[StackIndex--]];
X++;
if (X == Width) {
X = 0;
if (Interlaced) {
if ((Y & 7) == 0) { Y += 8; if (Y >= Height) Y = 4; }
else if ((Y & 3) == 0) { Y += 8; if (Y >= Height) Y = 2; }
else if ((Y & 1) == 0) { Y += 4; if (Y >= Height) Y = 1; }
else Y += 2;
} else {
Y++;
}
}
if (Y == Height) {
break;
}
}
}
if (EntryIndex >= (1 << CodeSize)) {
if (CodeSize < 12) {
CodeSize++;
} else {
//Print (L"bad code");
continue;
}
}
PrevCode = Code;
}
return ReadBits;
}
Reference in New Issue View Git Blame Copy Permalink