internal void MatchFinderMt_CreateVTable(out IMatchFinder vTable)
{
// Careful: don't use this.mNumHashBytes - it hasn't been initialized yet!
TR("MatchFinderMt_CreateVTable", base.mNumHashBytes);
switch (base.mNumHashBytes)
{
case 2:
vTable = mInterface = new MatchFinderMt2();
break;
case 3:
vTable = mInterface = new MatchFinderMt3();
break;
default:
#if PROTOTYPE
vTable = mInterface = new MatchFinderMt5();
break;
case 4:
#endif
if (base.mBigHash)
{
vTable = mInterface = new MatchFinderMt4b();
}
else
{
vTable = mInterface = new MatchFinderMt4a();
}
break;
}
}
private Match[] FindMatches(Stream input, int compressionMode, int huffmanMode)
{
IMatchFinder[] matchFinders;
switch (compressionMode)
{
case 1:
matchFinders = new[]
{
new HybridSuffixTreeMatchFinder(
new FindLimitations(3, 18, 1, 0xFFFF),
new FindOptions(false, 0, 0, UnitSize.Byte, 8))
};
break;
case 2:
matchFinders = new[]
{
new HybridSuffixTreeMatchFinder(
new FindLimitations(3, -1, 1, 0xFFFF),
new FindOptions(false, 0, 0, UnitSize.Byte, 8))
};
break;
case 3:
//var newLength = input.Length >> 1 << 1;
matchFinders = new[]
{
new HybridSuffixTreeMatchFinder(
new FindLimitations(4, -1, 2, 0xFFFF),
new FindOptions(false, 0, 0, UnitSize.Short, 8))
};
break;
case 4:
return(Array.Empty <Match>());
case 5:
matchFinders = new IMatchFinder[]
{
new HybridSuffixTreeMatchFinder(new FindLimitations(3, 0x42, 1, 0xFFFF),
new FindOptions(false, 0, 0, UnitSize.Byte, 8)),
new RleMatchFinder(new FindLimitations(1, 0x40),
new FindOptions(false, 0, 0, UnitSize.Byte, 8))
};
break;
default:
throw new InvalidOperationException($"Unknown compression mode {compressionMode}.");
}
// Optimal parse all LZ matches
var parser = new ForwardBackwardOptimalParser(
new FindOptions(false, 0, 0, compressionMode == 3 ? UnitSize.Short : UnitSize.Byte, 8),
new SlimePriceCalculator(compressionMode, huffmanMode),
matchFinders);
return(parser.ParseMatches(input).ToArray());
}
// =============================================================
// Code
// =============================================================
public byte[] Compress(byte[] input)
{
Output = new BitEncoder();
Matcher = new HashChain8(input, 26, 32);
for (int i = 0; i < SymbolProbabilities.Length; i++)
{
SymbolProbabilities[i].Init();
}
for (int i = 0; i < DistanceScaleProbabilities.Length; i++)
{
DistanceScaleProbabilities[i].Init();
}
int inputSize = input.Length;
int inputOffset = 1;
EncodeSymbol(input[0], 0); // Emit the first byte as a literal with no context.
while (inputOffset <= inputSize)
{
var match = FindBestMatch(inputOffset);
bool matchAvailable = match.Benefit > 0;
if (matchAvailable)
{
var nextMatch = PeekNextMatch(inputOffset + 1);
if (nextMatch.Benefit > match.Benefit)
{
matchAvailable = false;
}
}
if (matchAvailable)
{
if (matchAvailable)
{
if (match.Length > 255)
{
match.Length = 255;
}
EncodeSymbol(256 + match.Length, input[inputOffset - 1]);
EncodeDistance(match.Distance);
inputOffset += match.Length;
}
}
else
{
EncodeSymbol(input[inputOffset], input[inputOffset - 1]);
inputOffset++;
}
if (inputOffset == inputSize)
{
break;
}
}
return(Output.GetBytes());
}
internal static void MatchFinder_CreateVTable(CMatchFinder p, out IMatchFinder vTable)
{
TR("MatchFinder_CreateVTable", p.mNumHashBytes);
if (!p.mBtMode)
vTable = new MatchFinderHc4();
else if (p.mNumHashBytes == 2)
vTable = new MatchFinderBt2();
else if (p.mNumHashBytes == 3)
vTable = new MatchFinderBt3();
else
vTable = new MatchFinderBt4();
}
public byte[] Compress(byte[] input, LZBPerformance mode = LZBPerformance.NORMAL)
{
switch (mode)
{
case LZBPerformance.L1_VeryFast: Matcher = new HashTable3(input, 21); LazyParse = false; break;
case LZBPerformance.L2_VeryFast: Matcher = new HashTable3(input, 21); LazyParse = true; break;
case LZBPerformance.NORMAL: Matcher = new MetaHT3HC4HC8(input, 21, 32); LazyParse = true; break;
}
Writer = new BitWriterFast();
CachedPosition = -1;
int inputSize = input.Length;
int inputOffset = 0;
while (inputOffset < inputSize)
{
var match = FindBestMatch(inputOffset);
bool matchAvailable = match.Benefit > 0;
if (LazyParse && matchAvailable)
{
var nextMatch = PeekNextMatch(inputOffset + 1);
if (nextMatch.Benefit > match.Benefit + 9)
{
matchAvailable = false;
}
}
if (matchAvailable)
{
if (match.Length > MAX_MATCH)
{
match.Length = MAX_MATCH;
}
Writer.WriteBits(1, 1);
EncodeMatchLength(match.Length);
EncodeMatchOffset(match.Distance);
inputOffset += match.Length;
}
else
{
Writer.WriteBits(input[inputOffset++] << 1, 9);
}
}
return(Writer.GetBuffer());
}
private IMatchFinder[] BuildMatchFinders(FindOptions options)
{
if (_matchFinderFactories.Count != _limitFactories.Count)
{
throw new InvalidOperationException("Not all match finders have limitations to search patterns in.");
}
var matchFinders = new IMatchFinder[_limitFactories.Count];
for (var i = 0; i < _limitFactories.Count; i++)
{
var limits = _limitFactories[i]();
var matchFinder = _matchFinderFactories[i](limits, options);
matchFinders[i] = matchFinder;
}
return(matchFinders);
}
private IMatchFinder[] BuildMatchFinders(FindOptions options)
{
if (_matchFinderFactories.Count != _limitFactories.Count)
{
throw new InvalidOperationException("One match finder has no limitations.");
}
var matchFinders = new IMatchFinder[_limitFactories.Count];
for (var i = 0; i < _limitFactories.Count; i++)
{
var limit = _limitFactories[i]();
var matchFinder = _matchFinderFactories[i](options, limit);
matchFinders[i] = matchFinder;
}
return(matchFinders);
}
TTransaction2[] unmatchedTransactions2) GetMatches(
IMatchFinder <TTransaction1, TTransaction2> matcher,
IList <TTransaction1> transactions1,
IList <TTransaction2> transactions2)
{
var matches = matcher.GetMatches(transactions1, transactions2);
var unmatchedTransactions1 = transactions1
.Except(
matches.Select(x => x.Item1))
.ToArray();
var unmatchedTransactions2 = transactions2
.Except(
matches.Select(x => x.Item2))
.ToArray();
return(matches, unmatchedTransactions1, unmatchedTransactions2);
}
internal static void MatchFinder_CreateVTable(CMatchFinder p, out IMatchFinder vTable)
{
//TR("MatchFinder_CreateVTable", p.mNumHashBytes);
if (!p.mBtMode)
{
vTable = new MatchFinderHc4();
}
else if (p.mNumHashBytes == 2)
{
vTable = new MatchFinderBt2();
}
else if (p.mNumHashBytes == 3)
{
vTable = new MatchFinderBt3();
}
else
{
vTable = new MatchFinderBt4();
}
}
internal static void Prepare(Func <Arena, IArenaFactory> factory_factory, Func <Arena, int, IMatchFinder> match_finder_factory, ref List <IMatchFinder> match_finders_sink, ref List <IArenaFactory> arena_sink) //LOL, don't care.
{
for (var i = 0; i < ArenaTypesCount; ++i)
{
var arena = arena_enum_values[i + 1];
for (var j = 0; j < MaxTeamSizeValue; ++j)
{
var team_size = team_size_enum_values[j];
IArenaFactory factory = null;
IMatchFinder match_finder = null;
if (ArenaOps.IsMatchSizeSupported(arena, team_size))
{
factory = factory_factory(arena);
match_finder = match_finder_factory(arena, j + 1);
}
match_finders_sink.Add(match_finder);
arena_sink.Add(factory); //The team size as human number
}
}
}
void Create()
{
if (_matchFinder == null)
{
BinTree bt = new BinTree();
int numHashBytes = 4;
if (_matchFinderType == EMatchFinderType.BT2)
numHashBytes = 2;
bt.SetType(numHashBytes);
_matchFinder = bt;
}
_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits);
if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)
return;
_matchFinder.Create(_dictionarySize, kNumOpts, _numFastBytes, Base.kMatchMaxLen + 1);
_dictionarySizePrev = _dictionarySize;
_numFastBytesPrev = _numFastBytes;
}
public void SetCoderProperties(CoderPropID[] propIDs, object[] properties)
{
for (UInt32 i = 0; i < properties.Length; i++)
{
object prop = properties[i];
switch (propIDs[i])
{
case CoderPropID.NumFastBytes:
{
if (!(prop is Int32))
throw new InvalidParamException();
Int32 numFastBytes = (Int32)prop;
if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen)
throw new InvalidParamException();
_numFastBytes = (UInt32)numFastBytes;
break;
}
case CoderPropID.Algorithm:
{
/*
if (!(prop is Int32))
throw new InvalidParamException();
Int32 maximize = (Int32)prop;
_fastMode = (maximize == 0);
_maxMode = (maximize >= 2);
*/
break;
}
case CoderPropID.MatchFinder:
{
if (!(prop is String))
throw new InvalidParamException();
EMatchFinderType matchFinderIndexPrev = _matchFinderType;
int m = FindMatchFinder(((string)prop).ToUpper());
if (m < 0)
throw new InvalidParamException();
_matchFinderType = (EMatchFinderType)m;
if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType)
{
_dictionarySizePrev = 0xFFFFFFFF;
_matchFinder = null;
}
break;
}
case CoderPropID.DictionarySize:
{
const int kDicLogSizeMaxCompress = 30;
if (!(prop is Int32))
throw new InvalidParamException(); ;
Int32 dictionarySize = (Int32)prop;
if (dictionarySize < (UInt32)(1 << Base.kDicLogSizeMin) ||
dictionarySize > (UInt32)(1 << kDicLogSizeMaxCompress))
throw new InvalidParamException();
_dictionarySize = (UInt32)dictionarySize;
int dicLogSize;
for (dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)
if (dictionarySize <= ((UInt32)(1) << dicLogSize))
break;
_distTableSize = (UInt32)dicLogSize * 2;
break;
}
case CoderPropID.PosStateBits:
{
if (!(prop is Int32))
throw new InvalidParamException();
Int32 v = (Int32)prop;
if (v < 0 || v > (UInt32)Base.kNumPosStatesBitsEncodingMax)
throw new InvalidParamException();
_posStateBits = (int)v;
_posStateMask = (((UInt32)1) << (int)_posStateBits) - 1;
break;
}
case CoderPropID.LitPosBits:
{
if (!(prop is Int32))
throw new InvalidParamException();
Int32 v = (Int32)prop;
if (v < 0 || v > (UInt32)Base.kNumLitPosStatesBitsEncodingMax)
throw new InvalidParamException();
_numLiteralPosStateBits = (int)v;
break;
}
case CoderPropID.LitContextBits:
{
if (!(prop is Int32))
throw new InvalidParamException();
Int32 v = (Int32)prop;
if (v < 0 || v > (UInt32)Base.kNumLitContextBitsMax)
throw new InvalidParamException(); ;
_numLiteralContextBits = (int)v;
break;
}
case CoderPropID.EndMarker:
{
if (!(prop is Boolean))
throw new InvalidParamException();
SetWriteEndMarkerMode((Boolean)prop);
break;
}
default:
throw new InvalidParamException();
}
}
}
public byte[] Compress(byte[] input, int windowBits = 26, NibLZPerformance mode = NibLZPerformance.NORMAL)
{
if (windowBits < 15 || windowBits > 28)
{
throw new ArgumentException("Invalid window size");
}
switch (mode)
{
case NibLZPerformance.VERY_FAST: Matcher = new HashTable3(input, windowBits); LazyParse = false; break;
case NibLZPerformance.FAST: Matcher = new HashChain3(input, windowBits, 4); LazyParse = false; break;
case NibLZPerformance.NORMAL: Matcher = new MetaHT3HC4(input, windowBits, 16); LazyParse = true; break;
case NibLZPerformance.BETTER: Matcher = new MetaHT3HC4HC8(input, windowBits, 16); LazyParse = true; break;
case NibLZPerformance.BEST: Matcher = new MetaHT3HC4HC8(input, windowBits, 64); LazyParse = true; break;
}
// Initialize state vars
Output.Clear();
int inputSize = input.Length;
CachedPosition = -1;
SecondNibbleAvailable = false;
SecondNibbleOffset = 0;
int inputOffset = 0;
int literalCount = 0;
// Compression loop
while (inputOffset <= inputSize)
{
var match = FindBestMatch(inputOffset);
bool matchAvailable = match.Benefit > 0;
if (matchAvailable && LazyParse)
{
var nextMatch = PeekNextMatch(inputOffset + 1);
if (literalCount != 7 && nextMatch.Benefit > match.Benefit)
{
matchAvailable = false;
}
}
if (matchAvailable || (inputOffset == inputSize)) // Time to write a command
{
if (literalCount > 0) // Emit literal packet if we've accumulated any literals
{
EmitLiteralCommand(literalCount);
for (int literalOffset = inputOffset - literalCount; literalOffset < inputOffset; literalOffset++)
{
Output.Add(input[literalOffset]);
}
literalCount = 0;
}
if (matchAvailable) // Emit match if available
{
EmitMatchCommand(match.Length);
Output.EncodeMod7(match.Distance - 1);
inputOffset += match.Length;
}
if (inputOffset == inputSize)
{
break;
}
}
else
{
inputOffset++;
literalCount++;
}
}
return(Output.ToArray());
}
internal void MatchFinderMt_CreateVTable(out IMatchFinder vTable)
{
// Careful: don't use this.mNumHashBytes - it hasn't been initialized yet!
TR("MatchFinderMt_CreateVTable", base.mNumHashBytes);
switch(base.mNumHashBytes)
{
case 2:
vTable = mInterface = new MatchFinderMt2();
break;
case 3:
vTable = mInterface = new MatchFinderMt3();
break;
default:
#if PROTOTYPE
vTable = mInterface = new MatchFinderMt5();
break;
case 4:
#endif
if(base.mBigHash)
vTable = mInterface = new MatchFinderMt4b();
else
vTable = mInterface = new MatchFinderMt4a();
break;
}
}
public byte[] Compress(byte[] input, int windowBits = 26, LZHPerformance mode = LZHPerformance.NORMAL)
{
switch (mode)
{
case LZHPerformance.L1_VeryFast: Matcher = new HashTable3(input, windowBits); LazyParse = false; break;
case LZHPerformance.L2_VeryFast: Matcher = new HashTable3(input, windowBits); LazyParse = true; break;
case LZHPerformance.L3_Fast: Matcher = new MetaHT3HC4(input, windowBits, 4); LazyParse = false; break;
case LZHPerformance.L4_Fast: Matcher = new MetaHT3HC4(input, windowBits, 4); LazyParse = true; break;
case LZHPerformance.NORMAL: Matcher = new MetaHT3HC4HC8(input, 26, 16); LazyParse = false; break;
case LZHPerformance.BETTER: Matcher = new MetaHT3HC4HC8(input, 26, 32); LazyParse = true; break;
}
int inputSize = input.Length;
int inputOffset = 0;
Output = new BitWriterFwd();
CachedPosition = -1;
CachedMatch = default;
SymbolFreqs = new int[NUM_SYMBOLS];
ChunkBuffer = new ushort[Math.Min(inputSize, CHUNK_SIZE)];
MatchEncodes = new Queue <MatchData>();
CalcChunkEnd(inputOffset, inputSize);
while (true)
{
var match = FindBestMatch(inputOffset);
bool matchAvailable = match.Benefit > 0;
if (matchAvailable && LazyParse)
{
var nextMatch = PeekNextMatch(inputOffset + 1);
if (nextMatch.Benefit > match.Benefit)
{
matchAvailable = false;
}
}
if (matchAvailable)
{
if (match.Length > MAX_MATCH)
{
match.Length = MAX_MATCH;
}
EmitMatch(match.Length, match.Distance);
inputOffset += match.Length;
}
else // No match available, emit literal
{
EmitSymbol(input[inputOffset++]);
}
// Encode chunk if we've reached end of chunk
if (inputOffset >= ChunkEnd)
{
if (ChunkEnd == inputSize)
{
EmitSymbol(SYM_EOF);
}
else
{
EmitSymbol(SYM_NEWTREE);
}
EncodeChunk();
if (inputOffset >= inputSize)
{
break;
}
CalcChunkEnd(inputOffset, inputSize);
}
}
return(Output.GetBuffer());
}
