{

MaxCompressedMessagesBytes = maxCompressedMessagesBytes;

CCtx = ZSTD_createCCtx();

if (!CCtx) {

return Result("SessionOutgoing::Initialize", "ZSTD_createCCtx failed", ErrorType::Zstd);

}

const size_t estimatedPacketSize = MaxCompressedMessagesBytes;

ZSTD_parameters zParams;

zParams.cParams = ZSTD_getCParams(

kCompressionLevel,

estimatedPacketSize,

kCompressionDictBytes);

zParams.fParams.checksumFlag = 0;

zParams.fParams.contentSizeFlag = 0;

zParams.fParams.noDictIDFlag = 1;

const size_t icsResult = ZSTD_compressBegin_advanced(

CCtx,

nullptr,

0,

zParams,

ZSTD_CONTENTSIZE_UNKNOWN);

if (0 != ZSTD_isError(icsResult)) {

TONK_DEBUG_BREAK();

return Result("SessionOutgoing::Initialize", "ZSTD_compressBegin_advanced failed", ErrorType::Zstd, icsResult);

}

const size_t blockSizeBytes = ZSTD_getBlockSize(CCtx);

if (blockSizeBytes < MaxCompressedMessagesBytes) {

return Result("SessionOutgoing::Initialize", "Zstd block size is too small", ErrorType::Zstd);

}

return Result::Success();

const uint8_t* data,

unsigned bytes,

uint8_t* destBuffer,

unsigned& writtenBytes)

{

TONK_DEBUG_ASSERT(bytes > 0 && destBuffer && data);

writtenBytes = 0;

// Insert data into history ring buffer

TONK_DEBUG_ASSERT(MaxCompressedMessagesBytes >= bytes);

void* history = History.Allocate(MaxCompressedMessagesBytes);

memcpy(history, data, bytes);

History.Commit(bytes);

// Compress into scratch buffer, leaving room for a frame header

const size_t result = ZSTD_compressBlock(

CCtx,

destBuffer,

MaxCompressedMessagesBytes,

history,

bytes);

// If no data to compress, or would require too much space,

// or did not produce a small enough result:

if (0 == result ||

(size_t)-ZSTD_error_dstSize_tooSmall == result ||

result >= bytes)

{

// Note: Input data was accumulated into history ring buffer

return Result::Success();

}

// If compression failed:

if (0 != ZSTD_isError(result))

{

std::string reason = "ZSTD_compressBlock failed: ";

reason += ZSTD_getErrorName(result);

TONK_DEBUG_BREAK();

return Result("SessionOutgoing::compress", reason, ErrorType::Zstd, result);

}

writtenBytes = static_cast<unsigned>(result);

TONK_DEBUG_ASSERT(writtenBytes <= MaxCompressedMessagesBytes);

return Result::Success();

{

MaxCompressedMessagesBytes = maxCompressedMessagesBytes;

DCtx = ZSTD_createDCtx();

if (!DCtx) {

return Result("SessionIncoming::Initialize", "ZSTD_createDCtx failed", ErrorType::Zstd);

}

const size_t beginResult = ZSTD_decompressBegin(DCtx);

if (0 != ZSTD_isError(beginResult)) {

return Result("SessionIncoming::Initialize", "ZSTD_decompressBegin failed", ErrorType::Zstd, beginResult);

}

return Result::Success();

const uint8_t* data,

unsigned bytes)

{

if (bytes > MaxCompressedMessagesBytes) {

TONK_DEBUG_BREAK(); // Invalid input

return;

}

void* history = History.Allocate(MaxCompressedMessagesBytes);

memcpy(history, data, bytes);

ZSTD_insertBlock(DCtx, history, bytes);

History.Commit(bytes);

const void* data,

unsigned bytes,

Decompressed& decompressed)

{

// Decompress data into history ring buffer

void* history = History.Allocate(MaxCompressedMessagesBytes);

const size_t result = ZSTD_decompressBlock(

DCtx,

history,

MaxCompressedMessagesBytes,

data,

bytes);

// If decompression failed:

if (0 == result || 0 != ZSTD_isError(result))

{

std::string reason = "ZSTD_decompressBlock failed: ";

reason += ZSTD_getErrorName(result);

TONK_DEBUG_BREAK();

return Result("SessionOutgoing::decompress", reason, ErrorType::Zstd, result);

}

const uint8_t* datagramData = reinterpret_cast<uint8_t*>(history);

const unsigned datagramBytes = static_cast<unsigned>(result);

History.Commit(datagramBytes);

decompressed.Data = datagramData;

decompressed.Bytes = datagramBytes;

return Result::Success();