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); }
public static void ZSTD_copyDDictParameters(ZSTD_DCtx_s *dctx, ZSTD_DDict_s *ddict) { assert(dctx != null); assert(ddict != null); dctx->dictID = ddict->dictID; dctx->prefixStart = ddict->dictContent; dctx->virtualStart = ddict->dictContent; dctx->dictEnd = (byte *)(ddict->dictContent) + ddict->dictSize; dctx->previousDstEnd = dctx->dictEnd; if (ddict->entropyPresent != 0) { dctx->litEntropy = 1; dctx->fseEntropy = 1; dctx->LLTptr = ddict->entropy.LLTable; dctx->MLTptr = ddict->entropy.MLTable; dctx->OFTptr = ddict->entropy.OFTable; dctx->HUFptr = ddict->entropy.hufTable; dctx->entropy.rep[0] = ddict->entropy.rep[0]; dctx->entropy.rep[1] = ddict->entropy.rep[1]; dctx->entropy.rep[2] = ddict->entropy.rep[2]; } else { dctx->litEntropy = 0; dctx->fseEntropy = 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); } }
/*! ZSTD_getDictID_fromDDict() : * Provides the dictID of the dictionary loaded into `ddict`. * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ public static uint ZSTD_getDictID_fromDDict(ZSTD_DDict_s *ddict) { if (ddict == null) { return(0); } return(ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize)); }
public static nuint ZSTD_sizeof_DDict(ZSTD_DDict_s *ddict) { if (ddict == null) { return(0); } return((nuint)(sizeof(ZSTD_DDict_s)) + (ddict->dictBuffer != null ? ddict->dictSize : 0)); }
/*! ZSTD_freeDDict() : * Function frees memory allocated with ZSTD_createDDict() */ public static nuint ZSTD_freeDDict(ZSTD_DDict_s *ddict) { if (ddict == null) { return(0); } { ZSTD_customMem cMem = ddict->cMem; ZSTD_customFree(ddict->dictBuffer, cMem); ZSTD_customFree((void *)ddict, cMem); return(0); } }
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); }
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); }
public static nuint ZSTD_DDict_dictSize(ZSTD_DDict_s *ddict) { assert(ddict != null); return(ddict->dictSize); }
/* note: several prototypes are already published in `zstd.h` : * ZSTD_createDDict() * ZSTD_createDDict_byReference() * ZSTD_createDDict_advanced() * ZSTD_freeDDict() * ZSTD_initStaticDDict() * ZSTD_sizeof_DDict() * ZSTD_estimateDDictSize() * ZSTD_getDictID_fromDict() */ public static void *ZSTD_DDict_dictContent(ZSTD_DDict_s *ddict) { assert(ddict != null); return(ddict->dictContent); }