// Section 2.4.1.3.6
// page 62
/// <summary>
/// Compresses the data given in UncompressedData.
/// </summary>
/// <param name="UncompressedData">Uncompressed raw data</param>
/// <returns>A byte array containing the compressed data</returns>
public static Byte[] Compress(byte[] UncompressedData)
{
if (UncompressedData == null)
{
throw new ArgumentNullException("UncompressedData");
}
var resultBuffer = new CompressedBuffer(UncompressedData.Length);
DecompressedBuffer uncompressedDataBuffer = new DecompressedBuffer(UncompressedData);
var state = new DecompressionState(uncompressedDataBuffer);
// 2.4.1.3.6 Compression algorithm
resultBuffer.SetByte(state.CompressedCurrent, 0x01);
++state.CompressedCurrent;
while (state.DecompressedCurrent < state.DecompressedBufferEnd)
{
state.CompressedChunkStart = state.CompressedCurrent;
state.DecompressedChunkStart = state.DecompressedCurrent;
CompressDecompressedChunk(UncompressedData, resultBuffer, state);
}
return(resultBuffer.GetData());
}
protected void DecompressTokenSequence(DecompressedBuffer buffer, DecompressionState state, IEnumerable <TokenSequence> tokenSequence)
{
foreach (var t in tokenSequence)
{
t.Decompress(buffer, state);
}
}
public void Decompress(DecompressedBuffer buffer, DecompressionState state)
{
state.DecompressedChunkStart = state.DecompressedCurrent;
//var CompressedEnd = Math.Min(state.CompressionRecordEnd, state.CompressedChunkStart + this.CompressedHeader.CompressedChunkSize);
state.CompressedCurrent += 2;
this.CompressedData.Decompress(buffer, state);
}
/*
* public Byte[] GetDataInRawBytes()
* {
* IEnumerable<Byte> result = new Byte[] { this.FlagByte };
* foreach(var token in _Tokens)
* {
* result = result.Concat(token.GetDataInRawBytes());
* }
*
* return result.ToArray();
* }*/
public void Decompress(DecompressedBuffer buffer, DecompressionState state)
{
++state.CompressedCurrent;
foreach (var token in this._Tokens)
{
token.Decompress(buffer, state);
}
}
/// <summary>
/// For compressing, where buffer is already filled with the fully decompressed data
/// </summary>
public DecompressionState(DecompressedBuffer buffer)
{
this.CompressionRecordEnd = 0; // unknown yet
this.CompressedCurrent = 0; // to start with
this.CompressedChunkStart = 0; // to start with
this.DecompressedCurrent = 0; // to start with
this.DecompressedBufferEnd = buffer.Data.Count(); // todo: or +1?
this.DecompressedChunkStart = 0; // to start with
}
public override void Decompress(DecompressedBuffer buffer, DecompressionState state)
{
var decompressedChunk = new DecompressedChunk(new byte[] { Data });
buffer.Add(decompressedChunk);
++state.DecompressedCurrent;
++state.CompressedCurrent;
}
public override void Decompress(DecompressedBuffer buffer, DecompressionState state)
{
var info = UnpackCopyToken(this.Token, state.DecompressedCurrent, state.DecompressedChunkStart);
var copySource = state.DecompressedCurrent - info.Offset;
// Call Byte Copy (section 2.4.1.3.11) with CopySource, DecompressedCurrent, and Length
ByteCopy(buffer, copySource, state.DecompressedCurrent, info.Length);
state.DecompressedCurrent += info.Length;
state.CompressedCurrent += 2;
}
public void DecompressRawChunk(DecompressedBuffer buffer, DecompressionState state, Byte[] Data)
{
throw new NotImplementedException();
Byte[] append = new Byte[4096];
//Array.Copy(state.OriginalData, state.CompressedCurrent, append, 0, header.CompressedChunkSize);
//int nCopy = Math.Min(4096, state.OriginalData.Length-state.CompressedCurrent);
//Array.Copy(state.OriginalData, state.CompressedCurrent, append, 0, nCopy);
Array.Copy(this.Data, 0, append, 0, 4096); // todo: maybe copy from original data?
state.DecompressedCurrent += 4096;
state.CompressedCurrent += 4096;
var x = new DecompressedChunk(append);
buffer.Add(x);
}
/// <summary>
/// Decompresses the given data
/// </summary>
/// <param name="CompressedData">Byte array of the compressed data</param>
/// <returns>A byte array containing the uncompressed data</returns>
public static Byte[] Decompress(byte[] CompressedData)
{
if (CompressedData == null)
{
throw new ArgumentNullException("CompressedData");
}
var reader = new XlBinaryReader(ref CompressedData);
reader.OutputAllAsBinary();
var container = new CompressedContainer(reader);
var buffer = new DecompressedBuffer();
container.Decompress(buffer);
Byte[] UncompressedCompressedData = buffer.GetData();
return(UncompressedCompressedData);
}
public void Decompress(DecompressedBuffer buffer)
{
var state = new DecompressionState();
if (this.SignatureByte == (Byte)0x01)
{
++state.CompressedCurrent;
foreach (var chunk in _Chunks)
{
state.CompressedChunkStart = state.CompressedCurrent;
chunk.Decompress(buffer, state);
}
}
else
{
throw new FormatException("Signature byte was not 0x01");
}
}
/// <summary>
///
/// </summary>
/// <param name="OriginalData"></param>
/// <param name="CopySource">Specifies the location, in the DecompressedBuffer, of the first byte of the source sequence</param>
/// <param name="DestinationSource">Specifies the location, in the DecompressedBuffer, of the first byte of the destination sequence</param>
/// <param name="ByteCount">Specifies the number of bytes to copy. MUST be greater than 0.</param>
protected void ByteCopy(DecompressedBuffer buffer, int CopySource, int DestinationSource, int ByteCount)
{
if (ByteCount <= 0)
{
throw new ArgumentOutOfRangeException("ByteCount", ByteCount, "ByteCount must be greater than 0");
}
var SrcCurrent = CopySource;
var DstCurrent = DestinationSource;
for (int i = 1; i <= ByteCount; i++)
{
var byteToCopy = buffer.GetByteAt(SrcCurrent);
//var byteToCopy = OriginalData.ReadByteAt(SrcCurrent);
buffer.SetByte(DstCurrent, byteToCopy);
++SrcCurrent;
++DstCurrent;
}
}
public abstract void Decompress(DecompressedBuffer buffer, DecompressionState state);
public static void Decompress(DecompressedBuffer outputBuffer, CompressedContainer container)
{
}
