private static uint HashPosition(void *p, TableTypeT tableType) { #if !BIT32 if (tableType != TableTypeT.ByU16) { return(Hash5(ReadArch(p), tableType)); } #endif return(Hash4(LZ4MemoryHelper.Peek32(p), tableType)); }
protected static byte *GetPositionOnHash(uint h, void *tableBase, TableTypeT tableType, byte *srcBase) { switch (tableType) { case TableTypeT.ByPtr: return(((byte **)tableBase)[h]); case TableTypeT.ByU32: return(((uint *)tableBase)[h] + srcBase); default: return(((ushort *)tableBase)[h] + srcBase); } }
protected static void PutPositionOnHash(byte *p, uint h, void *tableBase, TableTypeT tableType, byte *srcBase) { switch (tableType) { case TableTypeT.ByPtr: ((byte **)tableBase)[h] = p; return; case TableTypeT.ByU32: ((uint *)tableBase)[h] = (uint)(p - srcBase); return; default: ((ushort *)tableBase)[h] = (ushort)(p - srcBase); return; } }
private static int CompressDestSizeGeneric(StreamT *ctx, byte *src, byte *dst, int *srcSizePtr, int targetDstSize, TableTypeT tableType) { byte *ip = src; byte *srcBase = src; byte *lowLimit = src; byte *anchor = ip; byte *iend = ip + *srcSizePtr; byte *mflimit = iend - MFLimit; byte *matchlimit = iend - LastLiterals; byte *op = dst; byte *oend = op + targetDstSize; byte *oMaxLit = op + targetDstSize - 2 - 8 - 1; byte *oMaxMatch = op + targetDstSize - (LastLiterals + 1); byte *oMaxSeq = oMaxLit - 1; if (targetDstSize < 1) { return(0); } if (*srcSizePtr > MaxInputSize) { return(0); } if ((tableType == TableTypeT.ByU16) && (*srcSizePtr >= Limit64k)) { return(0); } if (*srcSizePtr < LZ4MinLength) { goto _last_literals; // Input too small, no compression (all literals) } *srcSizePtr = 0; PutPosition(ip, ctx->HashTable, tableType, srcBase); ip++; uint forwardH = HashPosition(ip, tableType); for (; ;) { byte *match; byte *token; { byte *forwardIp = ip; uint step = 1u; uint searchMatchNb = 1u << SkipTrigger; do { uint h = forwardH; ip = forwardIp; forwardIp += step; step = searchMatchNb++ >> SkipTrigger; if (forwardIp > mflimit) { goto _last_literals; } match = GetPositionOnHash(h, ctx->HashTable, tableType, srcBase); forwardH = HashPosition(forwardIp, tableType); PutPositionOnHash(ip, h, ctx->HashTable, tableType, srcBase); }while ((tableType != TableTypeT.ByU16) && (match + MaxDistance < ip) || (LZ4MemoryHelper.Peek32(match) != LZ4MemoryHelper.Peek32(ip))); } while ((ip > anchor) && (match > lowLimit) && (ip[-1] == match[-1])) { ip--; match--; } { uint litLength = (uint)(ip - anchor); token = op++; if (op + (litLength + 240) / 255 + litLength > oMaxLit) { op--; goto _last_literals; } if (litLength >= RunMask) { uint len = litLength - RunMask; *token = (byte)(RunMask << MLBits); for (; len >= 255; len -= 255) { *op++ = 255; } *op++ = (byte)len; } else { *token = (byte)(litLength << MLBits); } LZ4MemoryHelper.WildCopy(op, anchor, op + litLength); op += litLength; } _next_match: LZ4MemoryHelper.Poke16(op, (ushort)(ip - match)); op += 2; { int matchLength = (int)Count(ip + MinMatch, match + MinMatch, matchlimit); if (op + (matchLength + 240) / 255 > oMaxMatch) { matchLength = (int)(15 - 1 + (oMaxMatch - op) * 255); } ip += MinMatch + matchLength; if (matchLength >= MLMask) { *token += (byte)MLMask; matchLength -= (int)MLMask; while (matchLength >= 255) { matchLength -= 255; *op++ = 255; } *op++ = (byte)matchLength; } else { *token += (byte)matchLength; } } anchor = ip; if (ip > mflimit) { break; } if (op > oMaxSeq) { break; } PutPosition(ip - 2, ctx->HashTable, tableType, srcBase); match = GetPosition(ip, ctx->HashTable, tableType, srcBase); PutPosition(ip, ctx->HashTable, tableType, srcBase); if ((match + MaxDistance >= ip) && (LZ4MemoryHelper.Peek32(match) == LZ4MemoryHelper.Peek32(ip))) { token = op++; *token = 0; goto _next_match; } forwardH = HashPosition(++ip, tableType); } _last_literals: { int lastRunSize = (int)(iend - anchor); if (op + 1 + (lastRunSize + 240) / 255 + lastRunSize > oend) { lastRunSize = (int)(oend - op) - 1; lastRunSize -= (lastRunSize + 240) / 255; } ip = anchor + lastRunSize; if (lastRunSize >= RunMask) { long accumulator = lastRunSize - RunMask; *op++ = (byte)(RunMask << MLBits); for (; accumulator >= 255; accumulator -= 255) { *op++ = 255; } *op++ = (byte)accumulator; } else { *op++ = (byte)(lastRunSize << MLBits); } LZ4MemoryHelper.Copy(op, anchor, lastRunSize); op += lastRunSize; } *srcSizePtr = (int)(ip - src); return((int)(op - dst)); }
public static int CompressGeneric(StreamT *cctx, byte *source, byte *dest, int inputSize, int maxOutputSize, LimitedOutputDirective outputLimited, TableTypeT tableType, DictDirective dict, DictIssueDirective dictIssue, uint acceleration) { byte *ip = source; byte *ibase; byte *lowLimit; byte *lowRefLimit = ip - cctx->DictSize; byte *dictionary = cctx->Dictionary; byte *dictEnd = dictionary + cctx->DictSize; long dictDelta = dictEnd - source; byte *anchor = source; byte *iend = ip + inputSize; byte *mflimit = iend - MFLimit; byte *matchlimit = iend - LastLiterals; byte *op = dest; byte *olimit = op + maxOutputSize; if (inputSize > MaxInputSize) { return(0); } switch (dict) { case DictDirective.WithPrefix64k: ibase = source - cctx->CurrentOffset; lowLimit = source - cctx->DictSize; break; case DictDirective.UsingExtDict: ibase = source - cctx->CurrentOffset; lowLimit = source; break; default: ibase = source; lowLimit = source; break; } if ((tableType == TableTypeT.ByU16) && (inputSize >= Limit64k)) { return(0); } if (inputSize < LZ4MinLength) { goto _last_literals; } PutPosition(ip, cctx->HashTable, tableType, ibase); ip++; uint forwardH = HashPosition(ip, tableType); for (; ;) { long refDelta = 0L; byte *match; byte *token; { byte *forwardIp = ip; uint step = 1u; uint searchMatchNb = acceleration << SkipTrigger; do { uint h = forwardH; ip = forwardIp; forwardIp += step; step = searchMatchNb++ >> SkipTrigger; if (forwardIp > mflimit) { goto _last_literals; } match = GetPositionOnHash(h, cctx->HashTable, tableType, ibase); if (dict == DictDirective.UsingExtDict) { if (match < source) { refDelta = dictDelta; lowLimit = dictionary; } else { refDelta = 0; lowLimit = source; } } forwardH = HashPosition(forwardIp, tableType); PutPositionOnHash(ip, h, cctx->HashTable, tableType, ibase); }while ((dictIssue == DictIssueDirective.DictSmall) && (match < lowRefLimit) || (tableType != TableTypeT.ByU16) && (match + MaxDistance < ip) || (LZ4MemoryHelper.Peek32(match + refDelta) != LZ4MemoryHelper.Peek32(ip))); } while ((ip > anchor) && (match + refDelta > lowLimit) && (ip[-1] == match[refDelta - 1])) { ip--; match--; } { uint litLength = (uint)(ip - anchor); token = op++; if ((outputLimited == LimitedOutputDirective.LimitedOutput) && (op + litLength + (2 + 1 + LastLiterals) + litLength / 255 > olimit)) { return(0); } if (litLength >= RunMask) { int len = (int)(litLength - RunMask); *token = (byte)(RunMask << MLBits); for (; len >= 255; len -= 255) { *op++ = 255; } *op++ = (byte)len; } else { *token = (byte)(litLength << MLBits); } LZ4MemoryHelper.WildCopy(op, anchor, op + litLength); op += litLength; } _next_match: LZ4MemoryHelper.Poke16(op, (ushort)(ip - match)); op += 2; { uint matchCode; if ((dict == DictDirective.UsingExtDict) && (lowLimit == dictionary)) { match += refDelta; byte *limit = ip + (dictEnd - match); if (limit > matchlimit) { limit = matchlimit; } matchCode = Count(ip + MinMatch, match + MinMatch, limit); ip += MinMatch + matchCode; if (ip == limit) { uint more = Count(ip, source, matchlimit); matchCode += more; ip += more; } } else { matchCode = Count(ip + MinMatch, match + MinMatch, matchlimit); ip += MinMatch + matchCode; } if ((outputLimited == LimitedOutputDirective.LimitedOutput) && (op + (1 + LastLiterals) + (matchCode >> 8) > olimit)) { return(0); } if (matchCode >= MLMask) { *token += (byte)MLMask; matchCode -= MLMask; LZ4MemoryHelper.Poke32(op, 0xFFFFFFFF); while (matchCode >= 4 * 255) { op += 4; LZ4MemoryHelper.Poke32(op, 0xFFFFFFFF); matchCode -= 4 * 255; } op += matchCode / 255; *op++ = (byte)(matchCode % 255); } else { *token += (byte)matchCode; } } anchor = ip; if (ip > mflimit) { break; } PutPosition(ip - 2, cctx->HashTable, tableType, ibase); match = GetPosition(ip, cctx->HashTable, tableType, ibase); if (dict == DictDirective.UsingExtDict) { if (match < source) { refDelta = dictDelta; lowLimit = dictionary; } else { refDelta = 0; lowLimit = source; } } PutPosition(ip, cctx->HashTable, tableType, ibase); if ((dictIssue != DictIssueDirective.DictSmall || match >= lowRefLimit) && (match + MaxDistance >= ip) && (LZ4MemoryHelper.Peek32(match + refDelta) == LZ4MemoryHelper.Peek32(ip))) { token = op++; *token = 0; goto _next_match; } forwardH = HashPosition(++ip, tableType); } _last_literals: { int lastRun = (int)(iend - anchor); if ((outputLimited == LimitedOutputDirective.LimitedOutput) && (op - dest + lastRun + 1 + (lastRun + 255 - RunMask) / 255 > (uint)maxOutputSize)) { return(0); } if (lastRun >= RunMask) { int accumulator = (int)(lastRun - RunMask); *op++ = (byte)(RunMask << MLBits); for (; accumulator >= 255; accumulator -= 255) { *op++ = 255; } *op++ = (byte)accumulator; } else { *op++ = (byte)(lastRun << MLBits); } LZ4MemoryHelper.Copy(op, anchor, lastRun); op += lastRun; } return((int)(op - dest)); }
private static byte *GetPosition(byte *p, void *tableBase, TableTypeT tableType, byte *srcBase) { return(GetPositionOnHash(HashPosition(p, tableType), tableBase, tableType, srcBase)); }
private static void PutPosition(byte *p, void *tableBase, TableTypeT tableType, byte *srcBase) { PutPositionOnHash(p, HashPosition(p, tableType), tableBase, tableType, srcBase); }
protected static uint Hash5(ulong sequence, TableTypeT tableType) { int hashLog = tableType == TableTypeT.ByU16 ? HashLog + 1 : HashLog; return((uint)(((sequence << 24) * 889523592379ul) >> (64 - hashLog))); }
protected static uint Hash4(uint sequence, TableTypeT tableType) { int hashLog = tableType == TableTypeT.ByU16 ? HashLog + 1 : HashLog; return((sequence * 2654435761u) >> (MinMatch * 8 - hashLog)); }