/// <summary>
/// I'm too lazy to comment this one. It basically finds the biggest previous clump of bytes that can replicate the current bytes
/// </summary>
private static ClumpInfo FindBestClumpOrig(byte[] rawData, int offset, int maxReadBack, int maxByteClump, int minByteClump)
{
ClumpInfo currentBestClump = new ClumpInfo(-1, -1, -1);
int startRef = Math.Max(offset - maxReadBack, 0);
for (int refOffset = startRef; refOffset < offset && refOffset < rawData.Length; refOffset += 2)
{
int matchCount = 0;
while (matchCount < maxByteClump && offset + matchCount < rawData.Length && rawData[refOffset + matchCount] == rawData[offset + matchCount])
{
matchCount++;
}
if (matchCount % 2 == 1)
{
matchCount--;
}
if (matchCount >= minByteClump && matchCount > currentBestClump.Length)
{
currentBestClump = new ClumpInfo(offset, offset - refOffset, matchCount);
if (matchCount == maxByteClump)
{
break;
}
}
}
return(currentBestClump);
}
private static bool FindBestAlternativeClumps(byte[] rawData, int maxReadBack, int maxByteClump, int minByteClump,
List <ClumpInfo> origClumps, int clumpOffset)
{
//The idea is to shave off a byte at the beginning of the clump. If it improves the # of bytes used, then goodie goodie!
//To do: look into shaving the end as well!
int oldLayoutBitCount = 1;
int oldByteCount = 2;
bool isInOldClump = true;
int oldClumpOffset = clumpOffset;
int newLayoutBitCount = 1;
int newByteCount = 1;
bool isInNewClump = false;
int newClumpOffset = 0;
List <ClumpInfo> newClumps = new List <ClumpInfo>();
int byteOffset = origClumps[clumpOffset].Offset + 1;
while (byteOffset < rawData.Length)
{
if ((!isInNewClump || newClumps[newClumpOffset].FollowingByte == byteOffset) &&
(!isInOldClump || origClumps[oldClumpOffset].FollowingByte == byteOffset))
{
break; //We are synced again, make sure to increment the oldClumpOffset so you don't overwrite a clump
}
//If we're not in a clump, try to generate a clump. If successful, add it in and jump in.
if (isInNewClump)
{
//Check if we need to exit
if (newClumps[newClumpOffset].FollowingByte == byteOffset)
{
newClumpOffset++;
//Try to generate new clump
ClumpInfo newClump = FindBestClump(rawData, byteOffset, maxReadBack, maxByteClump, minByteClump);
if (newClump.Offset != -1)
{
//jump into new clump
newClumps.Add(newClump);
newLayoutBitCount++;
newByteCount += 2;
}
else
{
isInNewClump = false;
newLayoutBitCount++;
newByteCount++;
}
}
}
else
{
//Try to generate.
ClumpInfo newClump = FindBestClump(rawData, byteOffset, maxReadBack, maxByteClump, minByteClump);
if (newClump.Offset != -1)
{
//jump into new clump
newClumps.Add(newClump);
isInNewClump = true;
newLayoutBitCount++;
newByteCount += 2;
}
else
{
newLayoutBitCount++;
newByteCount++;
}
}
//Handle the old info
if (isInOldClump)
{
//Check if we need to exit
if (origClumps[oldClumpOffset].FollowingByte == byteOffset)
{
oldClumpOffset++;
if (oldClumpOffset < origClumps.Count && origClumps[oldClumpOffset].Offset == byteOffset)
{
//jump into new clump
oldLayoutBitCount++;
oldByteCount += 2;
}
else
{
isInOldClump = false;
oldLayoutBitCount++;
oldByteCount++;
}
}
}
else
{
//Check if we enter
if (oldClumpOffset < origClumps.Count && origClumps[oldClumpOffset].Offset == byteOffset)
{
isInOldClump = true;
oldLayoutBitCount++;
oldByteCount += 2;
}
else
{
oldLayoutBitCount++;
oldByteCount++;
}
}
//if (isInNewClump && isInOldClump && origClumps[oldClumpOffset].LastByte == newClumps[newClumpOffset].LastByte)
// break; //We are synced again
//if (!isInOldClump && !isInNewClump)
// break; //We are synced again
byteOffset++;
}
if (newByteCount > oldByteCount || (newByteCount == oldByteCount && newLayoutBitCount >= oldLayoutBitCount))
{
return(false);
}
//make sure to go back an index if we're not in a clump
if (!isInOldClump)
{
oldClumpOffset--;
}
//Apply
int j;
for (j = oldClumpOffset; j > clumpOffset; j--)
{
origClumps.RemoveAt(j);
}
origClumps.RemoveAt(j);
while (newClumps.Count > 0)
{
origClumps.Insert(j, newClumps.Last());
newClumps.RemoveAt(newClumps.Count - 1);
}
return(true);
//Idea: have an algorithm that'll take a given clump, bump one byte off the start and step through bytes, incrementing
// the old and new clumps until they match up again. Remember to try to create clumps before ending the algorithm. If
// you can't drop it, consider recursively running the alogritm over it again, allowing for one more extra raw byte to be
// injected somewhere. If that doesn't work, failure!
}
private static ClumpInfo FindBestClump(byte[] rawData, int offset, int maxReadBack, int maxByteClump, int minByteClump)
{
ClumpInfo currentBestClump = new ClumpInfo(-1, -1, -1);
int startRef = Math.Max(offset - maxReadBack, 0);
for (int refOffset = startRef; refOffset < offset && refOffset < rawData.Length; refOffset++)
{
int matchCount = 0;
while (matchCount < maxByteClump && offset + matchCount < rawData.Length && rawData[refOffset + matchCount] == rawData[offset + matchCount])
matchCount++;
if (matchCount >= minByteClump && matchCount > currentBestClump.Length)
{
currentBestClump = new ClumpInfo(offset, offset - refOffset, matchCount);
if (matchCount == maxByteClump)
break;
}
}
return currentBestClump;
}
