TCompress Class Reference

#include <TCompress.h>

Classes
struct	Header

Static Public Member Functions
static size_t	Compress (TFile *file, TBYTE *data, TUINT32 size, TUINT32 unused, TBOOL isBigEndian)
static uintptr_t	Decompress (TFile *file, TCompress::Header *header, TBYTE *buffer, TUINT32 bufferSize)
static int8_t	GetHeader (TFile *file, TCompress::Header &btecHeader)
static TINT	GetCommand (TFile *file, TBOOL &hasOffset, TUINT32 &size, TINT &offset)

Static Public Attributes
static constexpr TUINT32	HEADER_SIZE_12 = sizeof( Header ) - sizeof( Header::XorValue )
static constexpr TUINT32	HEADER_SIZE_13 = sizeof( Header )
static TBOOL	ms_bIsBigEndian = false
static constexpr TINT	maxlength = 0x4000
static TINT	usemaxoffset

Detailed Description

Definition at line 29 of file TCompress.h.

Member Function Documentation

Compress()

TSIZE TCompress::Compress ( TFile * file, TBYTE * data, TUINT32 size, TUINT32 unused, TBOOL isBigEndian )

static

Definition at line 89 of file TCompress_Compress.cpp.

{
    BTECCompressor compressor;
 
    usemaxoffset = 0x8000;
    compressor.Initialize( buffer, size, usemaxoffset, 3 );
 
    TBYTE* bufferPos = buffer;
    TBYTE* bufferEnd = buffer + size;
 
    auto initialPos = file->Tell();
    file->Seek( TCompress::HEADER_SIZE_12, TSEEK_CUR );
 
    TSIZE  compressedSize = 0;
    TSIZE  chunkSize      = 0;
    TBYTE* chunkStart     = TNULL;
 
    while ( bufferPos < bufferEnd )
    {
        TSIZE uncompressedLeft = TMath::Min<TSIZE>( size - ( bufferPos - buffer ), maxlength );
 
        TBYTE* offset    = TNULL;
        TSIZE  dataSize  = 0;
        TBOOL  hasOffset = compressor.FUN_0068af10( bufferPos, uncompressedLeft, offset, dataSize );
 
        if ( hasOffset == TFALSE || dataSize < 3 )
        {
            dataSize = 1;
 
            // Check if we have to start a new chunk
            if ( chunkStart == TNULL ) chunkStart = bufferPos;
            chunkSize += 1;
 
            if ( maxlength <= chunkSize )
            {
                // Write a chunk of data
                compressedSize += TCompress::Write( chunkSize, chunkStart, file );
                chunkStart = TNULL;
                chunkSize  = 0;
            }
 
            bufferPos += 1;
        }
        else
        {
            if ( chunkStart != TNULL )
            {
                // We found an offset but we have a not-written chunk of data so write it
                compressedSize += TCompress::Write( chunkSize, chunkStart, file );
                chunkStart = TNULL;
                chunkSize  = 0;
            }
 
            compressedSize += TCompress::WriteOffset( dataSize, bufferPos - offset, bufferPos, file );
        }
 
        compressor.FUN_0068ae40( dataSize );
    }
 
    if ( chunkStart != TNULL )
    {
        // We are out of the while loop but still have some chunk of data that should be written
        compressedSize += TCompress::Write( chunkSize, chunkStart, file );
    }
 
    TCompress::Header btecHeader;
    btecHeader.Magic          = TFourCC( "BTEC" );
    btecHeader.Version        = TVERSION( 1, 2 );
    btecHeader.CompressedSize = compressedSize;
    btecHeader.Size           = size;
 
    if ( isBigEndian )
    {
        btecHeader.Magic          = PARSEDWORD_BIG( btecHeader.Magic );
        btecHeader.Version        = PARSEDWORD_BIG( btecHeader.Version );
        btecHeader.CompressedSize = PARSEDWORD_BIG( btecHeader.CompressedSize );
        btecHeader.Size           = PARSEDWORD_BIG( btecHeader.Size );
    }
 
    file->Seek( initialPos, TSEEK_SET );
    file->Write( &btecHeader, TCompress::HEADER_SIZE_12 );
    file->Seek( compressedSize, TSEEK_CUR );
 
    return compressedSize;
}

Decompress()

uintptr_t TCompress::Decompress ( TFile * file, TCompress::Header * header, TBYTE * buffer, TUINT32 bufferSize )

static

Definition at line 13 of file TCompress_Decompress.cpp.

{
    TPROFILER_SCOPE();
 
    if ( header->Magic != TFourCC( "BTEC" ) )
        return TCOMPRESS_ERROR_WRONG_MAGIC;
    if ( header->Version != TVERSION( 1, 2 ) && header->Version != TVERSION( 1, 3 ) )
        return TCOMPRESS_ERROR_WRONG_VERSION;
    if ( header->Size > bufferSize )
        return TCOMPRESS_ERROR_WRONG_SIZE;
 
    TBYTE*  pBufferPos     = buffer;
    TUINT32 compressedLeft = header->CompressedSize;
 
    while ( compressedLeft > 0 )
    {
        TUINT32 chunkSize;
        TBOOL   noOffset;
        TINT    offset;
 
        compressedLeft -= GetCommand( file, noOffset, chunkSize, offset );
 
        if ( !noOffset )
        {
            // The data is already unpacked so just copy it
            TBYTE* unpackedData = pBufferPos - offset;
 
            while ( chunkSize > 0 )
            {
                *( pBufferPos++ ) = *( unpackedData++ );
                chunkSize--;
            }
        }
        else
        {
            // The data wasn't previously unpacked, read it from file
            TSIZE readedCount = file->Read( pBufferPos, chunkSize );
            pBufferPos += readedCount;
            compressedLeft -= readedCount;
        }
    }
 
    if ( header->Version == TVERSION( 1, 3 ) )
    {
        pBufferPos = buffer;
        for ( TSIZE i = 0; i < header->Size; i++, pBufferPos++ )
        {
            *pBufferPos ^= header->XorValue;
        }
    }
 
    uintptr_t sizeDecompressed = pBufferPos - buffer;
    TASSERT( sizeDecompressed == header->Size, "Wrong decompressed size" );
 
    return sizeDecompressed;
}

GetCommand()

TINT TCompress::GetCommand ( TFile * file, TBOOL & hasOffset, TUINT32 & size, TINT & offset )

static

Definition at line 114 of file TCompress_Decompress.cpp.

{
    TINT  read_count = file->Read( &size, 1 );
    TBOOL isBigSize  = size & BTECSizeFlag_BigSize;
    noOffset         = size & BTECSizeFlag_NoOffset;
    offset           = -1;
 
    // by default size is 6 bits long
    size &= BTECSizeFlag_SizeMask;
 
    if ( isBigSize )
    {
        // now the size is 14 bits long
        uint8_t secondByte;
        read_count += file->Read( &secondByte, 1 );
        size = ( size << 8 ) | secondByte;
    }
 
    if ( !noOffset )
    {
        // by default offset is 7 bits long
        read_count += file->Read( &offset, 1 );
        TBOOL bigOffset = offset & BTECOffsetFlag_BigOffset;
        offset &= BTECOffsetFlag_OffsetMask;
 
        if ( bigOffset )
        {
            // now the offset is 15 bits long
            uint8_t secondByte;
            read_count += file->Read( &secondByte, 1 );
            offset = ( offset << 8 ) | secondByte;
        }
    }
 
    size += 1;
    offset += 1;
 
    return read_count;
}

GetHeader()

int8_t TCompress::GetHeader ( TFile * file, TCompress::Header & btecHeader )

static

Definition at line 71 of file TCompress_Decompress.cpp.

{
    TUINT32 headerSize = TCompress::HEADER_SIZE_12;
    TUINT32 savedPos   = file->Tell();
    TSIZE   readedSize = file->Read( &btecHeader, headerSize );
 
    if ( ms_bIsBigEndian )
    {
        btecHeader.Size           = CONVERTENDIANESS( Endianess_Big, btecHeader.Size );
        btecHeader.CompressedSize = CONVERTENDIANESS( Endianess_Big, btecHeader.CompressedSize );
        btecHeader.Magic          = CONVERTENDIANESS( Endianess_Big, btecHeader.Magic );
        btecHeader.Version        = CONVERTENDIANESS( Endianess_Big, btecHeader.Version.Value );
    }
 
    if ( btecHeader.Version == TVERSION( 1, 3 ) )
    {
        readedSize += file->Read( &btecHeader.XorValue, sizeof( TCompress::Header::XorValue ) );
        headerSize += sizeof( TCompress::Header::XorValue );
 
        if ( ms_bIsBigEndian )
        {
            btecHeader.XorValue = CONVERTENDIANESS( Endianess_Big, btecHeader.XorValue );
        }
    }
 
    if ( readedSize != headerSize )
    {
        file->Seek( savedPos, TSEEK_SET );
        return TCOMPRESS_ERROR_WRONG_HEADERSIZE;
    }
 
    if ( btecHeader.Magic != TFourCC( "BTEC" ) )
    {
        file->Seek( savedPos, TSEEK_SET );
        return TCOMPRESS_ERROR_WRONG_MAGIC;
    }
 
    return TCOMPRESS_ERROR_OK;
}

Member Data Documentation

HEADER_SIZE_12

TUINT32 TCompress::HEADER_SIZE_12 = sizeof( Header ) - sizeof( Header::XorValue )

staticconstexpr

Definition at line 46 of file TCompress.h.

HEADER_SIZE_13

TUINT32 TCompress::HEADER_SIZE_13 = sizeof( Header )

staticconstexpr

Definition at line 49 of file TCompress.h.

maxlength

TINT TCompress::maxlength = 0x4000

staticconstexpr

Definition at line 59 of file TCompress.h.

ms_bIsBigEndian

TBOOL TCompress::ms_bIsBigEndian = false

inlinestatic

Definition at line 52 of file TCompress.h.

usemaxoffset

TINT TCompress::usemaxoffset

static

Definition at line 60 of file TCompress.h.

---

The documentation for this class was generated from the following files:

• D:/_dev/OpenBarnyard/Source/Toshi/Source/File/TCompress.h
• D:/_dev/OpenBarnyard/Source/Toshi/Source/File/TCompress_Compress.cpp
• D:/_dev/OpenBarnyard/Source/Toshi/Source/File/TCompress_Decompress.cpp