Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

332 lines
7.9 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// LZMA Codec interface for engine. Based largely on LzmaUtil.c in SDK
//
// LZMA SDK 9.38 beta
// 2015-01-03 : Igor Pavlov : Public domain
// http://www.7-zip.org/
//
//========================================================================//
#ifdef POSIX
#include <stdlib.h>
#endif
#include "tier0/memdbgon.h"
#include "../../public/tier1/lzmaDecoder.h"
#include "C/7zTypes.h"
#include "C/LzmaEnc.h"
#include "C/LzmaDec.h"
#include "tier0/dbg.h"
// Allocator to pass to LZMA functions
static void *SzAlloc(void *p, size_t size) { return malloc(size); }
static void SzFree(void *p, void *address) { free(address); }
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
// lzma buffers will have a 13 byte trivial header
// [0] reserved
// [1..4] dictionary size, little endian
// [5..8] uncompressed size, little endian low word
// [9..12] uncompressed size, little endian high word
// [13..] lzma compressed data
#define LZMA_ORIGINAL_HEADER_SIZE 13
SRes CInStreamRam_StaticRead(void *p, void *buf, size_t *size );
size_t COutStreamRam_StaticWrite(void *p, const void *buf, size_t size);
class CInStreamRam : public ISeqInStream
{
const Byte *Data;
size_t Size;
size_t Pos;
public:
void Init(const Byte *data, size_t size)
{
Data = data;
Size = size;
Pos = 0;
Read = CInStreamRam_StaticRead;
}
SRes DoRead( void *buf, size_t *size )
{
size_t inSize = *size;
UInt32 remain = Size - Pos;
if (inSize > remain)
inSize = remain;
for (UInt32 i = 0; i < inSize; i++)
((Byte *)buf)[i] = Data[Pos + i];
Pos += inSize;
*size = inSize;
return SZ_OK;
}
};
class COutStreamRam: public ISeqOutStream
{
size_t Size;
public:
Byte *Data;
size_t Pos;
bool Overflow;
void Init(Byte *data, size_t size)
{
Data = data;
Size = size;
Pos = 0;
Overflow = false;
Write = COutStreamRam_StaticWrite;
}
size_t DoWrite( const void *buf, size_t size )
{
UInt32 i;
for (i = 0; i < size && Pos < Size; i++)
Data[Pos++] = ((const Byte *)buf)[i];
if (i != size)
{
Overflow = true;
}
return i;
}
};
SRes CInStreamRam_StaticRead(void *p, void *buf, size_t *size )
{
return reinterpret_cast<CInStreamRam *>(p)->DoRead( buf, size );
}
size_t COutStreamRam_StaticWrite(void *p, const void *buf, size_t size)
{
return reinterpret_cast<COutStreamRam *>(p)->DoWrite( buf, size );
}
SRes
LzmaEncode( const Byte *inBuffer,
size_t inSize,
Byte *outBuffer,
size_t outSize,
size_t *outSizeProcessed )
{
// Based on Encode helper in SDK/LzmaUtil
*outSizeProcessed = 0;
const size_t kMinDestSize = LZMA_ORIGINAL_HEADER_SIZE;
if ( outSize < kMinDestSize )
{
return SZ_ERROR_FAIL;
}
CLzmaEncHandle enc;
SRes res;
CLzmaEncProps props;
enc = LzmaEnc_Create( &g_Alloc );
if ( !enc )
{
return SZ_ERROR_FAIL;
}
LzmaEncProps_Init( &props );
res = LzmaEnc_SetProps( enc, &props );
if ( res != SZ_OK )
{
return res;
}
COutStreamRam outStream;
outStream.Init( outBuffer, outSize );
Byte header[LZMA_PROPS_SIZE + 8];
size_t headerSize = LZMA_PROPS_SIZE;
int i;
res = LzmaEnc_WriteProperties( enc, header, &headerSize );
if ( res != SZ_OK )
{
return res;
}
// Uncompressed size after properties in header
for (i = 0; i < 8; i++)
{
header[headerSize++] = (Byte)(inSize >> (8 * i));
}
if ( outStream.DoWrite( header, headerSize ) != headerSize )
{
res = SZ_ERROR_WRITE;
}
else if ( res == SZ_OK )
{
CInStreamRam inStream;
inStream.Init( inBuffer, inSize );
res = LzmaEnc_Encode( enc, &outStream, &inStream, NULL, &g_Alloc, &g_Alloc );
if ( outStream.Overflow )
{
res = SZ_ERROR_FAIL;
}
else
{
*outSizeProcessed = outStream.Pos;
}
}
LzmaEnc_Destroy( enc, &g_Alloc, &g_Alloc );
return res;
}
//-----------------------------------------------------------------------------
// Encoding glue. Returns non-null Compressed buffer if successful.
// Caller must free.
//-----------------------------------------------------------------------------
unsigned char *LZMA_Compress( unsigned char *pInput,
unsigned int inputSize,
unsigned int *pOutputSize )
{
*pOutputSize = 0;
// using same work buffer calcs as the SDK 105% + 64K
unsigned outSize = inputSize/20 * 21 + (1<<16);
unsigned char *pOutputBuffer = (unsigned char*)malloc( outSize );
if ( !pOutputBuffer )
{
return NULL;
}
// compress, skipping past our header
size_t compressedSize;
int result = LzmaEncode( pInput, inputSize, pOutputBuffer + sizeof( lzma_header_t ), outSize - sizeof( lzma_header_t ), &compressedSize );
if ( result != SZ_OK )
{
Warning( "LZMA encode failed (%i)\n", result );
Assert( result == SZ_OK );
free( pOutputBuffer );
return NULL;
}
// construct our header, strip theirs
lzma_header_t *pHeader = (lzma_header_t *)pOutputBuffer;
pHeader->id = LZMA_ID;
pHeader->actualSize = inputSize;
pHeader->lzmaSize = compressedSize - LZMA_ORIGINAL_HEADER_SIZE;
memcpy( pHeader->properties, pOutputBuffer + sizeof( lzma_header_t ), LZMA_PROPS_SIZE );
// shift the compressed data into place
memmove( pOutputBuffer + sizeof( lzma_header_t ),
pOutputBuffer + sizeof( lzma_header_t ) + LZMA_ORIGINAL_HEADER_SIZE,
compressedSize - LZMA_ORIGINAL_HEADER_SIZE );
// final output size is our header plus compressed bits
*pOutputSize = sizeof( lzma_header_t ) + compressedSize - LZMA_ORIGINAL_HEADER_SIZE;
return pOutputBuffer;
}
//-----------------------------------------------------------------------------
// Above, but returns null if compression would not yield a size improvement
//-----------------------------------------------------------------------------
unsigned char *LZMA_OpportunisticCompress( unsigned char *pInput,
unsigned int inputSize,
unsigned int *pOutputSize )
{
unsigned char *pRet = LZMA_Compress( pInput, inputSize, pOutputSize );
if ( *pOutputSize <= inputSize )
{
// compression got worse or stayed the same
free( pRet );
return NULL;
}
return pRet;
}
//-----------------------------------------------------------------------------
// Decoding glue. Returns TRUE if succesful.
//-----------------------------------------------------------------------------
bool LZMA_Uncompress( unsigned char *pInBuffer,
unsigned char **ppOutBuffer,
unsigned int *pOutSize )
{
*ppOutBuffer = NULL;
*pOutSize = 0;
lzma_header_t *pHeader = (lzma_header_t *)pInBuffer;
if ( pHeader->id != LZMA_ID )
{
// not ours
return false;
}
CLzmaDec state;
LzmaDec_Construct(&state);
if ( LzmaDec_Allocate(&state, pHeader->properties, LZMA_PROPS_SIZE, &g_Alloc) != SZ_OK )
{
return false;
}
unsigned char *pOutBuffer = (unsigned char *)malloc( pHeader->actualSize );
if ( !pOutBuffer )
{
LzmaDec_Free(&state, &g_Alloc);
return false;
}
// These are in/out variables
SizeT outProcessed = pHeader->actualSize;
SizeT inProcessed = pHeader->lzmaSize;
ELzmaStatus status;
SRes result = LzmaDecode( (Byte *)pOutBuffer, &outProcessed, (Byte *)(pInBuffer + sizeof( lzma_header_t ) ),
&inProcessed, (Byte *)pHeader->properties, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &g_Alloc );
LzmaDec_Free(&state, &g_Alloc);
if ( result != SZ_OK || pHeader->actualSize != outProcessed )
{
free( pOutBuffer );
return false;
}
*ppOutBuffer = pOutBuffer;
*pOutSize = pHeader->actualSize;
return true;
}
bool LZMA_IsCompressed( unsigned char *pInput )
{
lzma_header_t *pHeader = (lzma_header_t *)pInput;
if ( pHeader && pHeader->id == LZMA_ID )
{
return true;
}
// unrecognized
return false;
}
unsigned int LZMA_GetActualSize( unsigned char *pInput )
{
lzma_header_t *pHeader = (lzma_header_t *)pInput;
if ( pHeader && pHeader->id == LZMA_ID )
{
return pHeader->actualSize;
}
// unrecognized
return 0;
}