LzmaDecompress.c

Go to the documentation of this file.

 
#include "LzmaDecompressLibInternal.h"
#include "Sdk/C/7zTypes.h"
#include "Sdk/C/7zVersion.h"
#include "Sdk/C/LzmaDec.h"
 
#define SCRATCH_BUFFER_REQUEST_SIZE  SIZE_64KB
 
typedef struct {
  ISzAlloc    Functions;
  VOID        *Buffer;
  UINTN       BufferSize;
} ISzAllocWithData;
 
VOID *
SzAlloc (
  CONST ISzAlloc  *P,
  size_t          Size
  )
{
  VOID              *Addr;
  ISzAllocWithData  *Private;
 
  Private = (ISzAllocWithData *)P;
 
  if (Private->BufferSize >= Size) {
    Addr                 = Private->Buffer;
    Private->Buffer      = (VOID *)((UINT8 *)Addr + Size);
    Private->BufferSize -= Size;
    return Addr;
  } else {
    ASSERT (FALSE);
    return NULL;
  }
}
 
VOID
SzFree (
  CONST ISzAlloc  *P,
  VOID            *Address
  )
{
  //
  // We use the 'scratch buffer' for allocations, so there is no free
  // operation required.  The scratch buffer will be freed by the caller
  // of the decompression code.
  //
}
 
#define LZMA_HEADER_SIZE  (LZMA_PROPS_SIZE + 8)
 
UINT64
GetDecodedSizeOfBuf (
  UINT8  *EncodedData
  )
{
  UINT64  DecodedSize;
  INTN    Index;
 
  /* Parse header */
  DecodedSize = 0;
  for (Index = LZMA_PROPS_SIZE + 7; Index >= LZMA_PROPS_SIZE; Index--) {
    DecodedSize = LShiftU64 (DecodedSize, 8) + EncodedData[Index];
  }
 
  return DecodedSize;
}
 
//
// LZMA functions and data as defined in local LzmaDecompressLibInternal.h
//
 
RETURN_STATUS
EFIAPI
LzmaUefiDecompressGetInfo (
  IN  CONST VOID  *Source,
  IN  UINT32      SourceSize,
  OUT UINT32      *DestinationSize,
  OUT UINT32      *ScratchSize
  )
{
  UInt64  DecodedSize;
 
  ASSERT (SourceSize >= LZMA_HEADER_SIZE);
 
  DecodedSize = GetDecodedSizeOfBuf ((UINT8 *)Source);
  if (DecodedSize > MAX_UINT32) {
    return RETURN_UNSUPPORTED;
  }
 
  *DestinationSize = (UINT32)DecodedSize;
  *ScratchSize     = SCRATCH_BUFFER_REQUEST_SIZE;
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
LzmaUefiDecompress (
  IN CONST VOID  *Source,
  IN UINTN       SourceSize,
  IN OUT VOID    *Destination,
  IN OUT VOID    *Scratch
  )
{
  SRes              LzmaResult;
  ELzmaStatus       Status;
  SizeT             DecodedBufSize;
  SizeT             EncodedDataSize;
  ISzAllocWithData  AllocFuncs;
 
  AllocFuncs.Functions.Alloc = SzAlloc;
  AllocFuncs.Functions.Free  = SzFree;
  AllocFuncs.Buffer          = Scratch;
  AllocFuncs.BufferSize      = SCRATCH_BUFFER_REQUEST_SIZE;
 
  DecodedBufSize  = (SizeT)GetDecodedSizeOfBuf ((UINT8 *)Source);
  EncodedDataSize = (SizeT)(SourceSize - LZMA_HEADER_SIZE);
 
  LzmaResult = LzmaDecode (
                 Destination,
                 &DecodedBufSize,
                 (Byte *)((UINT8 *)Source + LZMA_HEADER_SIZE),
                 &EncodedDataSize,
                 Source,
                 LZMA_PROPS_SIZE,
                 LZMA_FINISH_END,
                 &Status,
                 &(AllocFuncs.Functions)
                 );
 
  if (LzmaResult == SZ_OK) {
    return RETURN_SUCCESS;
  } else {
    return RETURN_INVALID_PARAMETER;
  }
}