private static nuint ZSTD_loadEntropy_intoDDict(ZSTD_DDict_s *ddict, ZSTD_dictContentType_e dictContentType)
{
ddict->dictID = 0;
ddict->entropyPresent = 0;
if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_rawContent)
{
return(0);
}
if (ddict->dictSize < 8)
{
if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)));
}
return(0);
}
{
uint magic = MEM_readLE32(ddict->dictContent);
if (magic != 0xEC30A437)
{
if (dictContentType == ZSTD_dictContentType_e.ZSTD_dct_fullDict)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)));
}
return(0);
}
}
ddict->dictID = MEM_readLE32((void *)((sbyte *)(ddict->dictContent) + 4));
if ((ERR_isError(ZSTD_loadDEntropy(&ddict->entropy, ddict->dictContent, ddict->dictSize))) != 0)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionary_corrupted)));
}
ddict->entropyPresent = 1;
return(0);
}
public static ZSTD_DDict_s *ZSTD_createDDict_advanced(void *dict, nuint dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_customMem customMem)
{
if (((customMem.customAlloc == null ? 1 : 0) ^ (customMem.customFree == null ? 1 : 0)) != 0)
{
return((ZSTD_DDict_s *)null);
}
{
ZSTD_DDict_s *ddict = (ZSTD_DDict_s *)(ZSTD_customMalloc((nuint)(sizeof(ZSTD_DDict_s)), customMem));
if (ddict == null)
{
return((ZSTD_DDict_s *)null);
}
ddict->cMem = customMem;
{
nuint initResult = ZSTD_initDDict_internal(ddict, dict, dictSize, dictLoadMethod, dictContentType);
if ((ERR_isError(initResult)) != 0)
{
ZSTD_freeDDict(ddict);
return((ZSTD_DDict_s *)null);
}
}
return(ddict);
}
}
public static ZSTD_DDict_s *ZSTD_initStaticDDict(void *sBuffer, nuint sBufferSize, void *dict, nuint dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
{
nuint neededSpace = (nuint)(sizeof(ZSTD_DDict_s)) + (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef ? 0 : dictSize);
ZSTD_DDict_s *ddict = (ZSTD_DDict_s *)(sBuffer);
assert(sBuffer != null);
assert(dict != null);
if (((nuint)(sBuffer) & 7) != 0)
{
return((ZSTD_DDict_s *)null);
}
if (sBufferSize < neededSpace)
{
return((ZSTD_DDict_s *)null);
}
if (dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byCopy)
{
memcpy((void *)((ddict + 1)), (dict), (dictSize));
dict = ddict + 1;
}
if ((ERR_isError(ZSTD_initDDict_internal(ddict, dict, dictSize, ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, dictContentType))) != 0)
{
return((ZSTD_DDict_s *)null);
}
return(ddict);
}
private static nuint ZSTD_initDDict_internal(ZSTD_DDict_s *ddict, void *dict, nuint dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
{
if ((dictLoadMethod == ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef) || dict == null || dictSize == 0)
{
ddict->dictBuffer = null;
ddict->dictContent = dict;
if (dict == null)
{
dictSize = 0;
}
}
else
{
void *internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);
ddict->dictBuffer = internalBuffer;
ddict->dictContent = internalBuffer;
if (internalBuffer == null)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)));
}
memcpy((internalBuffer), (dict), (dictSize));
}
ddict->dictSize = dictSize;
ddict->entropy.hufTable[0] = (uint)((12) * 0x1000001);
{
nuint err_code = (ZSTD_loadEntropy_intoDDict(ddict, dictContentType));
if ((ERR_isError(err_code)) != 0)
{
return(err_code);
}
}
return(0);
}
