/// <summary>
/// Encodes all bytes currently stored in the encoder into target buffer.
/// </summary>
/// <param name="encoder">The encoder instance.</param>
/// <param name="target">The target buffer.</param>
/// <param name="offset">Offset in target buffer.</param>
/// <param name="length">Length of target buffer.</param>
/// <param name="allowCopy">If `true`, copying bytes is allowed.</param>
/// <returns>
/// Number of bytes encoded. If bytes were copied than this value is negative.
/// </returns>
public static unsafe int Encode(this ILZ4Encoder encoder, byte[] target, int offset, int length, bool allowCopy)
{
fixed(byte *targetPtr = target)
{
return(encoder.Encode(targetPtr + offset, length, allowCopy));
}
}
private static unsafe EncoderAction FlushAndEncode(
this ILZ4Encoder encoder,
byte *target, int targetLength,
bool forceEncode, bool allowCopy,
int loaded, out int encoded)
{
encoded = 0;
var blockSize = encoder.BlockSize;
var bytesReady = encoder.BytesReady;
if (bytesReady < (forceEncode ? 1 : blockSize))
{
return(loaded > 0 ? EncoderAction.Loaded : EncoderAction.None);
}
encoded = encoder.Encode(target, targetLength, allowCopy);
if (allowCopy && encoded < 0)
{
encoded = -encoded;
return(EncoderAction.Copied);
}
else
{
return(EncoderAction.Encoded);
}
}
public static unsafe bool Encode(
this ILZ4Encoder encoder, ref byte *target, int length, bool allowCopy)
{
var encoded = encoder.Encode(target, length, allowCopy);
target += encoded;
return(encoded != 0);
}
public static bool Encode(
this ILZ4Encoder encoder, byte[] target, ref int index, int length, bool allowCopy)
{
var encoded = encoder.Encode(target, index, length, allowCopy);
index += encoded;
return(encoded != 0);
}
/// <summary>
/// Encodes all bytes currently stored in encoder into target buffer.
/// </summary>
/// <param name="encoder">The encoder instance.</param>
/// <param name="target">Target buffer.</param>
/// <param name="offset">Offset in target buffer. Will be updated after operation.</param>
/// <param name="length">Length of target buffer.</param>
/// <param name="allowCopy">If `true`, copying bytes is allowed.</param>
/// <returns>
/// Result of this action. Bytes can be copied (<see cref="EncoderAction.Copied"/>),
/// encoded (<see cref="EncoderAction.Encoded"/>) or nothing could have
/// happened (<see cref="EncoderAction.None"/>).
/// </returns>
public static EncoderAction Encode(this ILZ4Encoder encoder, byte[] target, ref int offset, int length, bool allowCopy)
{
int encoded = encoder.Encode(target, offset, length, allowCopy);
offset += Math.Abs(encoded);
return(encoded == 0 ? EncoderAction.None :
encoded < 0 ? EncoderAction.Copied :
EncoderAction.Encoded);
}
/// <summary>
/// Encodes all bytes currently stored in encoder into target buffer.
/// </summary>
/// <param name="encoder">The encoder instance.</param>
/// <param name="target">Target buffer. Will be updated after operation.</param>
/// <param name="length">Length of buffer.</param>
/// <param name="allowCopy">If `true`, copying bytes is allowed.</param>
/// <returns>
/// Result of this action. Bytes can be copied (<see cref="EncoderAction.Copied"/>),
/// encoded (<see cref="EncoderAction.Encoded"/>) or nothing could have
/// happened (<see cref="EncoderAction.None"/>).
/// </returns>
public static unsafe EncoderAction Encode(this ILZ4Encoder encoder, ref byte *target, int length, bool allowCopy)
{
int encoded = encoder.Encode(target, length, allowCopy);
target += Math.Abs(encoded);
return(encoded == 0 ? EncoderAction.None :
encoded < 0 ? EncoderAction.Copied :
EncoderAction.Encoded);
}
private static void Flush(BinaryWriter outputWriter, ILZ4Encoder encoder, byte[] outputBuffer)
{
if (encoder.BytesReady <= 0)
{
return;
}
var encoded = encoder.Encode(outputBuffer, 0, outputBuffer.Length, false);
outputWriter.Write(encoded);
outputWriter.Write(outputBuffer, 0, encoded);
}
public static unsafe int Encode(
this ILZ4Encoder encoder, byte[] target, int index, int length, bool allowCopy)
{
fixed(byte *targetP = target)
return(encoder.Encode(targetP + index, length, allowCopy));
}
public unsafe int Encode(byte *target, int length, bool allowCopy) => _encoder.Encode(target, length, allowCopy);
