public void Compress()
{
if (!IsCompressed)
{
using var inBufferMem = MemoryPool <byte> .Shared.Rent(CompressedSize);
var inBuffer = inBufferMem.Memory.Span.Slice(0, CompressedSize);
mDataStream.Position = 0;
mDataStream.Read(inBufferMem.Memory.Span.Slice(0, CompressedSize));
using var outBufferMem = MemoryPool <byte> .Shared.Rent(UncompressedSize);
var outBuffer = outBufferMem.Memory.Span.Slice(0, UncompressedSize);
int compressedSize = 0;
if (UncompressedSize > 0)
{
compressedSize = HuffmanCodec.Compress(inBuffer, outBuffer);
}
mDataStream = new MemoryStream(UncompressedSize);
mDataStream.Write(outBuffer.Slice(0, compressedSize));
IsCompressed = true;
CompressedSize = compressedSize;
}
}
public CompressedImage Compress(Bitmap bmp)
{
if (bmp.PixelFormat != PixelFormat.Format24bppRgb)
{
throw new Exception($"{bmp.PixelFormat} pixel format is not supported, supported rgb24");
}
var pixelsMatrix = _pixelsExtractor.Extract(bmp);
var converterPixelsMatrix = MatrixRgbToYCbCrConveter.Convert(pixelsMatrix);
var residueYPiece = bmp.Height % (_thinIndex * _dctSize);
var residueXPiece = bmp.Width % (_thinIndex * _dctSize);
var countAddYPiece = residueYPiece == 0 ? 0 : _thinIndex * _dctSize - residueYPiece;
var countAddXPiece = residueXPiece == 0 ? 0 : _thinIndex * _dctSize - residueXPiece;
var extendedPixelsMatrix = _matrixExtender.Extend(converterPixelsMatrix, countAddYPiece, countAddXPiece);
var yCbCrchannels = _channelExtractor.Extract(extendedPixelsMatrix);
var thinnedCbChannel = _matrixThinner.Thin(yCbCrchannels.CbChannel, _thinIndex);
var thinnedCrChannel = _matrixThinner.Thin(yCbCrchannels.CrChannel, _thinIndex);
var dctYPieces = _dctCompressor.Compress(yCbCrchannels.YChannel, _dctSize, _compressionLevel, _lumiaMatrixProvider.GetMatrix());
var dctCbPieces = _dctCompressor.Compress(thinnedCbChannel, _dctSize, _compressionLevel, _colorMatrixProvider.GetMatrix());
var dctCrPieces = _dctCompressor.Compress(thinnedCrChannel, _dctSize, _compressionLevel, _colorMatrixProvider.GetMatrix());
var result = new List <byte>();
var countYBlocksPerColorBlock = _thinIndex * _thinIndex;
for (int i = 0, thinI = 0; i < dctYPieces.Length; thinI++)
{
for (var j = 0; j < countYBlocksPerColorBlock; j++)
{
result.AddRange(dctYPieces[i++]);
}
result.AddRange(dctCbPieces[thinI]);
result.AddRange(dctCrPieces[thinI]);
}
var rle = Rle <byte> .Encode(result).ToArray();
Dictionary <BitsWithLength, byte> decodeTable;
long bitsCount;
var huf = HuffmanCodec.Encode(rle, out decodeTable, out bitsCount);
var compressedImage = new CompressedImage
{
ThinIndex = _thinIndex,
CompressionLevel = _compressionLevel,
DataBytes = huf,
Height = extendedPixelsMatrix.GetLength(0),
Width = extendedPixelsMatrix.GetLength(1),
DecodeTable = decodeTable,
BitsCount = bitsCount
};
return(compressedImage);
}
public void CheckHuffmanTreeBuilderWorkOnFrequencies()
{
var frequencies = new [] {
0.14473691, 0.01147017, 0.00167522, 0.03831121, 0.00356579, 0.03811315,
0.00178254, 0.00199644, 0.00183511, 0.00225716, 0.00211240, 0.00308829,
0.00172852, 0.00186608, 0.00215921, 0.00168891, 0.00168603, 0.00218586,
0.00284414, 0.00161833, 0.00196043, 0.00151029, 0.00173932, 0.00218370,
0.00934121, 0.00220530, 0.00381211, 0.00185456, 0.00194675, 0.00161977,
0.00186680, 0.00182071, 0.06421956, 0.00537786, 0.00514019, 0.00487155,
0.00493925, 0.00503143, 0.00514019, 0.00453520, 0.00454241, 0.00485642,
0.00422407, 0.00593387, 0.00458130, 0.00343687, 0.00342823, 0.00531592,
0.00324890, 0.00333388, 0.00308613, 0.00293776, 0.00258918, 0.00259278,
0.00377105, 0.00267488, 0.00227516, 0.00415997, 0.00248763, 0.00301555,
0.00220962, 0.00206990, 0.00270369, 0.00231694, 0.00273826, 0.00450928,
0.00384380, 0.00504728, 0.00221251, 0.00376961, 0.00232990, 0.00312574,
0.00291688, 0.00280236, 0.00252436, 0.00229461, 0.00294353, 0.00241201,
0.00366590, 0.00199860, 0.00257838, 0.00225860, 0.00260646, 0.00187256,
0.00266552, 0.00242641, 0.00219450, 0.00192082, 0.00182071, 0.02185930,
0.00157439, 0.00164353, 0.00161401, 0.00187544, 0.00186248, 0.03338637,
0.00186968, 0.00172132, 0.00148509, 0.00177749, 0.00144620, 0.00192442,
0.00169683, 0.00209439, 0.00209439, 0.00259062, 0.00194531, 0.00182359,
0.00159096, 0.00145196, 0.00128199, 0.00158376, 0.00171412, 0.00243433,
0.00345704, 0.00156359, 0.00145700, 0.00157007, 0.00232342, 0.00154198,
0.00140730, 0.00288807, 0.00152830, 0.00151246, 0.00250203, 0.00224420,
0.00161761, 0.00714383, 0.08188576, 0.00802537, 0.00119484, 0.00123805,
0.05632671, 0.00305156, 0.00105584, 0.00105368, 0.00099246, 0.00090459,
0.00109473, 0.00115379, 0.00261223, 0.00105656, 0.00124381, 0.00100326,
0.00127550, 0.00089739, 0.00162481, 0.00100830, 0.00097229, 0.00078864,
0.00107240, 0.00084409, 0.00265760, 0.00116891, 0.00073102, 0.00075695,
0.00093916, 0.00106880, 0.00086786, 0.00185600, 0.00608367, 0.00133600,
0.00075695, 0.00122077, 0.00566955, 0.00108249, 0.00259638, 0.00077063,
0.00166586, 0.00090387, 0.00087074, 0.00084914, 0.00130935, 0.00162409,
0.00085922, 0.00093340, 0.00093844, 0.00087722, 0.00108249, 0.00098598,
0.00095933, 0.00427593, 0.00496661, 0.00102775, 0.00159312, 0.00118404,
0.00114947, 0.00104936, 0.00154342, 0.00140082, 0.00115883, 0.00110769,
0.00161112, 0.00169107, 0.00107816, 0.00142747, 0.00279804, 0.00085922,
0.00116315, 0.00119484, 0.00128559, 0.00146204, 0.00130215, 0.00101551,
0.00091756, 0.00161184, 0.00236375, 0.00131872, 0.00214120, 0.00088875,
0.00138570, 0.00211960, 0.00094060, 0.00088083, 0.00094564, 0.00090243,
0.00106160, 0.00088659, 0.00114514, 0.00095861, 0.00108753, 0.00124165,
0.00427016, 0.00159384, 0.00170547, 0.00104431, 0.00091395, 0.00095789,
0.00134681, 0.00095213, 0.00105944, 0.00094132, 0.00141883, 0.00102127,
0.00101911, 0.00082105, 0.00158448, 0.00102631, 0.00087938, 0.00139290,
0.00114658, 0.00095501, 0.00161329, 0.00126542, 0.00113218, 0.00123661,
0.00101695, 0.00112930, 0.00317976, 0.00085346, 0.00101190, 0.00189849,
0.00105728, 0.00186824, 0.00092908, 0.00160896,
};
var builder = new HuffmanTreeBuilder();
var table = builder.CreateTable(frequencies);
var codec = new HuffmanCodec(table);
}
public static long DPCM(Bitmap input, string param)
{
// Text parameters:
Dictionary <string, string> p = Util.ParseKeyValueList(param);
bool predict = false;
Util.TryParse(p, "predict", ref predict);
int width = input.Width;
int height = input.Height;
if (width < 1 || height < 1)
{
return(0L);
}
// Encoding, only dry-run in memory.
// Backend: adaptive Huffman encoder.
MemoryStream ms = new MemoryStream();
HuffmanCodec huff = new HuffmanCodec();
huff.BinaryStream = ms;
huff.MaxSymbol = 510; // -255 to +255
huff.Open(true);
// Predictive gray-pixel encoding:
int previous = 0;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
Color c = input.GetPixel(x, y);
int gr = Draw.RgbToGray(c.R, c.G, c.B);
if (predict)
{
huff.Put(gr - previous + 255);
previous = gr;
}
else
{
huff.Put(gr);
}
}
}
huff.Flush();
long result = ms.Length;
huff.Close();
return(result);
}
public void CheckCompressionOnRealText()
{
var text = File.ReadAllText("../../../poem.txt", Encoding.UTF8);
var data = Encoding.UTF8.GetBytes(text);
var treeBuilder = new HuffmanTreeBuilder();
var table = treeBuilder.CreateTable(data);
var codec = new HuffmanCodec(table);
var encodedData = codec.Encode(data);
Assert.True(encodedData.Length < data.Length);
}
public static unsafe int DecompressCpk(ReadOnlySpan <byte> source, Span <byte> destination)
{
fixed(byte *pInput = source)
{
var pHeader = (CompressedCpkHeader *)pInput;
HuffmanCodec.Decompress(
source.Slice(sizeof(CompressedCpkHeader), pHeader->CompressedSize),
destination.Slice(0, pHeader->UncompressedSize));
return(pHeader->UncompressedSize);
}
}
public void CopyTo(Span <byte> destination, bool decompress)
{
if (IsCompressed && decompress)
{
using var inBufferMem = MemoryPool <byte> .Shared.Rent(CompressedSize);
var inBuffer = inBufferMem.Memory.Span.Slice(0, CompressedSize);
Open(false).Read(inBufferMem.Memory.Span.Slice(0, CompressedSize));
HuffmanCodec.Decompress(inBuffer, destination);
}
else
{
Open(false).Read(destination);
}
}
public static unsafe int CompressCpk(ReadOnlySpan <byte> source, Span <byte> destination)
{
fixed(byte *pDest = destination)
{
var pHeader = (CompressedCpkHeader *)pDest;
pHeader->Field00 = 0;
pHeader->CompressedSize = source.Length;
pHeader->UncompressedSize = source.Length;
pHeader->Flags = 1;
pHeader->CompressedSize = HuffmanCodec.Compress(source, destination.Slice(sizeof(CompressedCpkHeader)), HuffmanCodec.DEFAULT_CHUNK_SIZE);
Trace.Assert(pHeader->CompressedSize < pHeader->UncompressedSize);
return(pHeader->CompressedSize + sizeof(CompressedCpkHeader));
}
}
public static void CheckCorruptionOnGuids()
{
const int testsAmount = 100;
var random = new Random();
var treeBuilder = new HuffmanTreeBuilder();
Parallel.For(0, testsAmount, i => {
var data = Guid.NewGuid().ToByteArray();
var table = treeBuilder.CreateTable(data);
var codec = new HuffmanCodec(table);
var encodedData = codec.Encode(data);
var decodedData = codec.Decode(encodedData);
Assert.Equal(data, decodedData);
});
}
public Bitmap Decompress(CompressedImage compressedImage)
{
var unHuf = HuffmanCodec.Decode(compressedImage.DataBytes, compressedImage.DecodeTable, compressedImage.BitsCount);
var unRle = Rle <byte> .Decode(unHuf).ToArray();
var yDct = new List <double>();
var cbDct = new List <double>();
var crDct = new List <double>();
var countYBlocks = compressedImage.ThinIndex * compressedImage.ThinIndex;
var cellsToBlock = compressedImage.CompressionLevel;
for (var i = 0; i < unRle.Length;)
{
for (var j = 0; j < countYBlocks * cellsToBlock; j++)
{
yDct.Add(unRle[i++]);
}
for (var j = 0; j < cellsToBlock; j++)
{
cbDct.Add(unRle[i++]);
}
for (var j = 0; j < cellsToBlock; j++)
{
crDct.Add(unRle[i++]);
}
}
var yDctBlocks = DevideIntoPiece(yDct, compressedImage.CompressionLevel);
var cbDctBlocks = DevideIntoPiece(cbDct, compressedImage.CompressionLevel);
var crDctBlocks = DevideIntoPiece(crDct, compressedImage.CompressionLevel);
var yChannel = _dctDecompressor.Decompress(yDctBlocks, _dctSize, compressedImage.Height, compressedImage.Width, _lumiaMatrixProvider.GetMatrix());
var thinnedCbChannel = _dctDecompressor.Decompress(cbDctBlocks, _dctSize, compressedImage.Height / compressedImage.ThinIndex, compressedImage.Width / compressedImage.ThinIndex, _colorMatrixProvider.GetMatrix());
var thinnedCrChannel = _dctDecompressor.Decompress(crDctBlocks, _dctSize, compressedImage.Height / compressedImage.ThinIndex, compressedImage.Width / compressedImage.ThinIndex, _colorMatrixProvider.GetMatrix());
var cbChannel = _pieceMatrixExtender.Extend(thinnedCbChannel, compressedImage.ThinIndex);
var crChannel = _pieceMatrixExtender.Extend(thinnedCrChannel, compressedImage.ThinIndex);
var yCbCrChannels = new YCbCrChannels(yChannel, cbChannel, crChannel);
var yCbCrPixels = _iChannelsPacker.Pack(yCbCrChannels, compressedImage.Height, compressedImage.Width);
var matrixRgbPixels = MatrixYCbCrToRgbConverter.Convert(yCbCrPixels);
var bmp = _bitmapBuilder.Build(matrixRgbPixels);
return(bmp);
}
public void CopyTo(Stream destination, bool decompress)
{
if (IsCompressed && decompress)
{
using var inBufferMem = MemoryPool <byte> .Shared.Rent(CompressedSize);
var inBuffer = inBufferMem.Memory.Span.Slice(0, CompressedSize);
Open(false).Read(inBufferMem.Memory.Span.Slice(0, CompressedSize));
using var outBufferMem = MemoryPool <byte> .Shared.Rent(UncompressedSize);
var outBuffer = outBufferMem.Memory.Span.Slice(0, UncompressedSize);
HuffmanCodec.Decompress(inBuffer, outBuffer);
destination.Write(outBuffer);
}
else
{
Open(false).CopyTo(destination);
}
}
public void Unpack(string directoryPath, Func <DwPackFileEntry, bool> callback)
{
var baseStreamLock = new object();
Parallel.ForEach(Entries, (entry =>
{
if (callback != null && !callback(entry))
{
return;
}
var unpackPath = Path.Combine(directoryPath, entry.Path);
var unpackDir = Path.GetDirectoryName(unpackPath);
Directory.CreateDirectory(unpackDir);
using var fileStream = File.Create(unpackPath);
if (entry.IsCompressed)
{
// Copy compressed data from basestream so we can decompress in parallel
var compressedBufferMem = MemoryPool <byte> .Shared.Rent(entry.CompressedSize);
var compressedBuffer = compressedBufferMem.Memory.Span.Slice(0, entry.CompressedSize);
lock (baseStreamLock)
entry.CopyTo(compressedBuffer, decompress: false);
// Decompress
using var outBufferMem = MemoryPool <byte> .Shared.Rent(entry.UncompressedSize);
var outBuffer = outBufferMem.Memory.Span.Slice(0, entry.UncompressedSize);
HuffmanCodec.Decompress(compressedBuffer, outBuffer);
fileStream.Write(outBuffer);
}
else
{
lock (baseStreamLock)
entry.CopyTo(fileStream, decompress: false);
}
}));
}
static void DoTesting()
{
var test = new Testing
{
OutputWriter = Console.Out
};
//TestGolomb();
//return;
//DumpCode();
//return;
//test.TestUniversalCodeBattery();
//test.TestUniversalCode(1, 10000);
//test.TestUniversalCode(1, 1U<<20,n=>5*n/3);
//test.TestUniversalCode(8, 1U << 28, n => 9*n/8);
//test.TestUniversalOnFiles(Testing.Paths[0]);
//return;
//var bs = new Bitstream();
////bs.OutputWriter = Console.Out;
//var ls1 = new List<uint> {1,4,4,9,1,34,4,0,0,76,1,34,10,34};
//ls1 = new List<uint> { 0x00, 0x2B, 0x4F, 0x81, 0x50, 0x2B, 0x56, 0x2B, 0x2C, 0x56, 0x56, 0x24, 0x24, 0x4F, 0x56, 0x25, 0x2B, 0x7B, 0x2B, 0x2C, 0x01, 0x2B, 0x81, 0x32, 0x32, 0x07, 0x07, 0x2B, 0x56, 0x06, 0x31, 0x00, 0xA5, 0x24, 0xAC, 0xAC, 0x50, 0x81, 0x81, 0x57, 0x01, 0x81, 0x81, 0x07, 0x5D, 0x00, 0x5C, 0x4F, 0x48, 0x81, 0xD7, 0x7A, 0x7A, 0xAC, 0x7B, 0x50, 0x75, 0x56, 0x81, 0x2D, 0x02, 0x81, 0x0E, 0x32, 0x81, 0x5C, 0x0C, 0x81, 0x73, 0x2B, 0xA5, 0x75, 0xA6, 0xD7, 0xA6, 0x75, 0x7B, 0x2D, 0x82, 0xAC, 0xAD, 0xAC, 0x88, 0x5D, 0x39, 0x15, 0x5D, 0xAC, 0x37, 0x0C, 0x6C, 0x9E, 0x56, 0x9F, 0xD1, 0x81, 0x82, 0x03, 0x2D, 0xD7, 0xAC, 0x03, 0x88, 0x15, 0x39, 0x88, 0x37, 0x12, 0x37, 0x87, 0x73, 0xA5, 0x9F, 0x9A, 0xA0, 0x58, 0x58, 0x2D, 0x2E, 0x2E, 0x04, 0xAC, 0x40, 0xB3, 0xD7, 0x62, 0x12, 0xAC, 0xD7, 0x81, 0x9E, 0x90, 0x97, 0x81, 0x81, 0xCA, 0xCB, 0xD1, 0x83, 0x04, 0x2E, 0x58, 0xAD, 0xD7, 0x40, 0x1C, 0x40, 0xAC, 0x81, 0x88, 0x1C, 0x88, 0x18, 0x62, 0x87, 0x3D, 0xAC, 0x97, 0xC9, 0x56, 0xA5, 0xD1, 0xBF, 0xBF, 0xC5, 0xD7, 0xCB, 0xD7, 0x59, 0x83, 0x6B, 0x23, 0x47, 0x6B, 0x3D, 0xB2, 0xD7, 0x2B, 0x9E, 0xB4, 0xBB, 0xBB, 0xD7, 0xD1, 0xCB, 0xCB, 0xC5, 0xC5, 0xD1, 0xD1, 0x59, 0x05, 0x05, 0x59, 0x56, 0x8F, 0x47, 0x88, 0x88, 0x8D, 0x43, 0xB2, 0xAC, 0x8D, 0x1E, 0x43, 0xBB, 0xD0, 0xCB, 0xAC, 0xAD, 0x2F, 0x83, 0xB3, 0x47, 0xB2, 0x43, 0x68, 0xBB, 0xC2, 0xC2, 0xD0, 0xD7, 0x83, 0x82, 0x8F, 0x8D, 0x68, 0x2B, 0xA5, 0xC9, 0xD1, 0xAD, 0x57, 0x2B, 0xB3, 0x8F, 0xB2, 0x8D, 0xAD, 0x83, 0xD7, 0x8F, 0xB3, 0x88, 0x56, 0xA5, 0xC9, 0xB3, 0xAC, 0x2B, 0xAD, 0xB3, 0x2B, 0x2B, 0x32, 0x56, 0x4F, 0x24, 0x50, 0x25, 0x57, 0x01, 0x56, 0x2C, 0x07, 0x06, 0x31, 0x56, 0x24, 0x48, 0x25, 0x7B, 0xAC, 0x2C, 0x07, 0x32, 0x30, 0x2A, 0x5C, 0x31, 0x55, 0x73, 0x48, 0x2B, 0x7B, 0x7B, 0x56, 0x2D, 0x02, 0x2C, 0x57, 0x57, 0x5D, 0x5D, 0x32, 0x0E, 0x0E, 0x5D, 0x0E, 0x30, 0x80, 0x5C, 0x55, 0x6C, 0xA5, 0xA6, 0xA6, 0x2D, 0x82, 0x88, 0x39, 0x80, 0x30, 0x5B, 0x5B, 0xAC, 0x9E, 0x97, 0x6C, 0x9E, 0x56, 0x7B, 0x7B, 0x75, 0x03, 0x2D, 0x15, 0xD7, 0x5B, 0x36, 0x86, 0x87, 0xB2, 0xA5, 0x90, 0x56, 0xA0, 0x75, 0xA0, 0x58, 0x82, 0x82, 0x58, 0xAD, 0x39, 0x56, 0x64, 0x15, 0x88, 0xD6, 0x86, 0xAB, 0x86, 0x5A, 0xA6, 0x9A, 0xA0, 0xD1, 0xAC, 0x58, 0x04, 0x2E, 0x1C, 0x88, 0xAC, 0xAB, 0x60, 0xC2, 0xBB, 0xC2, 0x56, 0xCB, 0xCB, 0xD7, 0x82, 0x04, 0x58, 0x2E, 0x57, 0x88, 0x40, 0x8C, 0x87, 0xA5, 0xBB, 0xC9, 0x56, 0xC9, 0xD7, 0xC5, 0xCB, 0x00, 0x82, 0x2F, 0xAD, 0x83, 0x59, 0x47, 0x23, 0x47, 0x88, 0x8C, 0x8B, 0xB1, 0xC2, 0x56, 0x7A, 0xC9, 0xD0, 0x59, 0x83, 0x83, 0x2B, 0x6B, 0x56, 0x8C, 0xC2, 0xC9, 0xC9, 0xAD, 0x59, 0x83, 0x5D, 0x6B, 0x6B, 0x6B, 0x8F, 0x8F, 0x2B, 0xD7, 0xD0, 0xD0, 0xD1, 0xCB, 0xB3, 0xB3, 0x81, 0x8C, 0xAC, 0xD0, 0xD0, 0xD7, 0x89, 0x81, 0x8F, 0x2B, 0x81, 0xB1, 0xB2, 0x81, 0xD1, 0xAD, 0xB3, 0xB3, 0x88, 0x87, 0xD6, 0xB2, 0xD6, 0xD7, 0xD6, 0x00, 0xFF, 0x00};
//UniversalCodec.BinaryAdaptiveSequentialEncode(bs,ls1);
//bs.Position = 0;
//Console.WriteLine();
//var ls2 = UniversalCodec.BinaryAdaptiveSequentialDecode(bs);
//Console.WriteLine();
//Console.WriteLine(CodecBase.CompareInts(ls1.ToArray(),ls2.ToArray()));
//
//return;
//DumpCode();
//return;
var codec77 = new Lz77Codec
{
//OutputWriter = Console.Out,
//MaximumDistance = 85,
//MaximumLength = 12,
//MinimumLength = 2
};
//codec77.Options |= Lz77Codec.OptionFlags.DumpHeader;
var codecCLbase = new LzclCodec {
CodecName = "LZCL"
};
codecCLbase.CompressionOptions &= ~CompressionChecker.OptionFlags.UseHuffman;
codecCLbase.CompressionOptions &= ~CompressionChecker.OptionFlags.UseArithmetic;
codecCLbase.CompressionOptions &= ~CompressionChecker.OptionFlags.UseGolomb;
var codecCl = new LzclCodec
{
CodecName = "LZCL",
//MaximumDistance = 85,
//MaximumLength = 12,
//MinimumLength = 2
};
//codecCl.OutputWriter = Console.Out;
//codecCl.CompressionOptions &= ~CompressionChecker.OptionFlags.UseArithmetic;
//codecCl.CompressionOptions &= ~CompressionChecker.OptionFlags.UseGolomb;
//codecCl.CompressionOptions &= ~CompressionChecker.OptionFlags.UseHuffman;
//codecCl.CompressionOptions &= ~CompressionChecker.OptionFlags.UseFixed;
//codecCl.CompressionOptions |= CompressionChecker.OptionFlags.UseStout;
//codecCl.CompressionOptions |= CompressionChecker.OptionFlags.UseBASC;
//codecCl.Options |= LZCLCodec.OptionFlags.ShowSavings;
//codecCl.Options |= LZCLCodec.OptionFlags.DumpOptimize;
codecCl.Options |= LzclCodec.OptionFlags.DumpDebug;
//codecCl.Options |= LZCLCodec.OptionFlags.ShowTallies;
codecCl.Options |= LzclCodec.OptionFlags.DumpCompressorSelections;
//var ds = DataSets.HypnoLightLogo;
//ds = File.ReadAllBytes(@"..\Corpus\Cantebury\asyoulik.txt");
//codecCL.Optimize(ds);
//return;
var codecH = new HuffmanCodec();
//codecH.OutputWriter = Console.Out;
//codecH.Options |= HuffmanCodec.OptionFlags.DumpDecoding;
//codecH.Options |= HuffmanCodec.OptionFlags.DumpEncoding;
//codecH.Options |= HuffmanCodec.OptionFlags.DumpHeader;
//codecH.Options |= HuffmanCodec.OptionFlags.DumpDictionary;
//codecH.Options &= ~HuffmanCodec.OptionFlags.UseLowMemoryDecoding;
var codecA = new ArithmeticCodec();
//codecA.OutputWriter = Console.Out;
//codecA.Options |= ArithmeticCodec.OptionFlags.DumpHeader;
//codecA.Options |= ArithmeticCodec.OptionFlags.DumpTable;
//codecA.Options |= ArithmeticCodec.OptionFlags.DumpState;
//codecA.Options |= ArithmeticCodec.OptionFlags.UseLowMemoryDecoding;
var codecF = new FixedSizeCodec();
var codecGolomb = new GolombCodec();
byte[] smallTest = { 1, 2, 5, 5, 7, 7, 7, 7, 8, 8, 5 };
var request = new Testing.Request
{
Codecs = new List <CodecBase>
{
codecH,
codecA,
codec77,
codecCl,
//codecGolomb,
//codecCLbase,
//codecF
},
// Codec = codec,
//TestData = smallTest,
//TestData = DataSets.HypnoLightLogo,
Filename = "*.*",
Path = Testing.Paths[0],
RecurseFiles = true,
//Decompress = false,
UseExternalDecompressor = true,
ShowOnlyErrors = false,
TrapErrors = true
};
test.DoTest(request);
//OutLogo();
// test.Optimize(DataSets.HypnoLightLogo);
}
static int PerformCommand(Options opts)
{
if (opts.Testing)
{
DoTesting();
return(1);
}
// create list of codecs
var codecs = new List <CodecBase>();
for (var i = 0; i < opts.CodecIndices.Count; ++i)
{
var ci = opts.CodecIndices[i];
CodecBase codec = null;
switch (CodecNames[ci])
{
case "Arithmetic":
codec = new ArithmeticCodec();
break;
case "Huffman":
codec = new HuffmanCodec();
break;
case "Lz77":
codec = new Lz77Codec();
break;
case "Lzcl":
codec = new LzclCodec();
break;
default:
Console.Error.WriteLine($"Unknown codec {CodecNames[ci]}");
break;
}
ApplyParameters(codec, opts.CodecParameters[i]);
if (codec != null)
{
codecs.Add(codec);
}
}
if (!codecs.Any())
{
Console.Error.WriteLine("No codec(s) specified");
return(-2);
}
if (opts.Verbose)
{
foreach (var c in codecs)
{
c.OutputWriter = Console.Out;
// todo - flags?
}
}
// if has input file and output file then do that
if (!String.IsNullOrEmpty(opts.Inputfile) && !String.IsNullOrEmpty(opts.Outputfile))
{
if (!File.Exists(opts.Inputfile))
{
Console.Error.WriteLine($"File {opts.Inputfile} does not exist");
Environment.Exit(-3);
}
// do first codec only
var data = File.ReadAllBytes(opts.Inputfile);
var watch = System.Diagnostics.Stopwatch.StartNew();
var output = opts.Decompress ? codecs[0].Decompress(data) : codecs[0].Compress(data);
var headerMsg = $"File {opts.Inputfile} compressed from {data.Length} to {output.Length} for {(double)output.Length/data.Length:F3} ratio";
if (codecs[0] is Lz77Codec)
{
var lz77 = codecs[0] as Lz77Codec;
var bufSize = Math.Max(lz77.MaximumDistance, lz77.MaximumLength) + 1;
headerMsg += $" LZ77 bufsize {bufSize}";
}
if (codecs[0] is LzclCodec)
{
var lzcl = codecs[0] as LzclCodec;
var bufSize = Math.Max(lzcl.MaximumDistance, lzcl.MaximumLength) + 1;
headerMsg += $" LZCL bufsize {bufSize}";
}
OutputData(opts.Outputfile, output, OutputFormats[opts.OutputFormatIndex], headerMsg);
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
var actionText = opts.Decompress ? "decompressed" : "compressed";
Console.WriteLine(
$"{Path.GetFileName(opts.Inputfile)} ({data.Length} bytes) {actionText} to {opts.Outputfile} ({output.Length} bytes).");
if (!opts.Decompress)
{
Console.WriteLine($"Compression ratio {100 - (100.0 * output.Length / data.Length):F1}%");
}
Console.WriteLine($"Elapsed time: {elapsedMs}ms");
return(1);
}
// if has only input file - do some testing
if (!String.IsNullOrEmpty(opts.Inputfile))
{
//public string Inputfile { get; set; } = "";
//public bool RecurseDirectories { get; set; } = false;
//public int OutputFormatIndex { get; set; } = -1;
//public bool Decompress { get; set; } = false;
var test = new Testing();
var request = new Testing.Request
{
Codecs = codecs,
Filename = "*.*",
Path = opts.Inputfile,
RecurseFiles = opts.RecurseDirectories,
// Decompress = false,
// UseExternalDecompressor = true,
ShowOnlyErrors = false,
TrapErrors = true
};
test.DoTest(request);
return(1);
}
Console.Error.WriteLine("Nothing to do");
return(-4);
}
public static long PCM(Bitmap input, string param)
{
// Text parameters:
Dictionary <string, string> p = Util.ParseKeyValueList(param);
bool BW = false;
Util.TryParse(p, "bw", ref BW);
int width = input.Width;
int height = input.Height;
if (width < 1 || height < 1)
{
return(0L);
}
// Encoding, only dry-run in memory.
// Backend: adaptive Huffman encoder.
MemoryStream ms = new MemoryStream();
HuffmanCodec huff = new HuffmanCodec();
huff.BinaryStream = ms;
huff.Open(true);
if (BW)
{
int buffer = 0;
int bufLen = 0;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int gr = (input.GetPixel(x, y).GetBrightness() < 0.5f) ? 0 : 1;
buffer += buffer + gr;
if (++bufLen == 8)
{
huff.Put(buffer & 0xff);
buffer = 0;
bufLen = 0;
}
}
// end of scanline
if (bufLen > 0)
{
buffer <<= 8 - bufLen;
huff.Put(buffer & 0xff);
buffer = 0;
bufLen = 0;
}
}
}
else
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
Color c = input.GetPixel(x, y);
int gr = Draw.RgbToGray(c.R, c.G, c.B);
huff.Put(gr);
}
}
}
huff.Flush();
long result = ms.Length;
huff.Close();
return(result);
}