// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Diagnostics;
namespace SharpCompress.Compressors.Deflate64
{
///
/// This class maintains a window for decompressed output.
/// We need to keep this because the decompressed information can be
/// a literal or a length/distance pair. For length/distance pair,
/// we need to look back in the output window and copy bytes from there.
/// We use a byte array of WindowSize circularly.
///
internal sealed class OutputWindow
{
// With Deflate64 we can have up to a 65536 length as well as up to a 65538 distance. This means we need a Window that is at
// least 131074 bytes long so we have space to retrieve up to a full 64kb in lookback and place it in our buffer without
// overwriting existing data. OutputWindow requires that the WindowSize be an exponent of 2, so we round up to 2^18.
private const int WINDOW_SIZE = 262144;
private const int WINDOW_MASK = 262143;
private readonly byte[] _window = new byte[WINDOW_SIZE]; // The window is 2^18 bytes
private int _end; // this is the position to where we should write next byte
private int _bytesUsed; // The number of bytes in the output window which is not consumed.
/// Add a byte to output window.
public void Write(byte b)
{
Debug.Assert(_bytesUsed < WINDOW_SIZE, "Can't add byte when window is full!");
_window[_end++] = b;
_end &= WINDOW_MASK;
++_bytesUsed;
}
public void WriteLengthDistance(int length, int distance)
{
Debug.Assert((_bytesUsed + length) <= WINDOW_SIZE, "No Enough space");
// move backwards distance bytes in the output stream,
// and copy length bytes from this position to the output stream.
_bytesUsed += length;
int copyStart = (_end - distance) & WINDOW_MASK; // start position for coping.
int border = WINDOW_SIZE - length;
if (copyStart <= border && _end < border)
{
if (length <= distance)
{
Array.Copy(_window, copyStart, _window, _end, length);
_end += length;
}
else
{
// The referenced string may overlap the current
// position; for example, if the last 2 bytes decoded have values
// X and Y, a string reference with
// adds X,Y,X,Y,X to the output stream.
while (length-- > 0)
{
_window[_end++] = _window[copyStart++];
}
}
}
else
{
// copy byte by byte
while (length-- > 0)
{
_window[_end++] = _window[copyStart++];
_end &= WINDOW_MASK;
copyStart &= WINDOW_MASK;
}
}
}
///
/// Copy up to length of bytes from input directly.
/// This is used for uncompressed block.
///
public int CopyFrom(InputBuffer input, int length)
{
length = Math.Min(Math.Min(length, WINDOW_SIZE - _bytesUsed), input.AvailableBytes);
int copied;
// We might need wrap around to copy all bytes.
int tailLen = WINDOW_SIZE - _end;
if (length > tailLen)
{
// copy the first part
copied = input.CopyTo(_window, _end, tailLen);
if (copied == tailLen)
{
// only try to copy the second part if we have enough bytes in input
copied += input.CopyTo(_window, 0, length - tailLen);
}
}
else
{
// only one copy is needed if there is no wrap around.
copied = input.CopyTo(_window, _end, length);
}
_end = (_end + copied) & WINDOW_MASK;
_bytesUsed += copied;
return copied;
}
/// Free space in output window.
public int FreeBytes => WINDOW_SIZE - _bytesUsed;
/// Bytes not consumed in output window.
public int AvailableBytes => _bytesUsed;
/// Copy the decompressed bytes to output array.
public int CopyTo(byte[] output, int offset, int length)
{
int copyEnd;
if (length > _bytesUsed)
{
// we can copy all the decompressed bytes out
copyEnd = _end;
length = _bytesUsed;
}
else
{
copyEnd = (_end - _bytesUsed + length) & WINDOW_MASK; // copy length of bytes
}
int copied = length;
int tailLen = length - copyEnd;
if (tailLen > 0)
{
// this means we need to copy two parts separately
// copy tailLen bytes from the end of output window
Array.Copy(_window, WINDOW_SIZE - tailLen,
output, offset, tailLen);
offset += tailLen;
length = copyEnd;
}
Array.Copy(_window, copyEnd - length, output, offset, length);
_bytesUsed -= copied;
Debug.Assert(_bytesUsed >= 0, "check this function and find why we copied more bytes than we have");
return copied;
}
}
}