public async Task Cancellation___OK()
{
var sut = new NoCompression();
var data = RawDataForTrendAsync();
var expected = RawDataForTrend().Take(2).ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var cts = new CancellationTokenSource();
var enumerator = dataPointIterator.GetAsyncEnumerator(cts.Token);
var actual = new List <DataPoint>();
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
cts.Cancel();
DataPoint[] res = null;
Assert.ThrowsAsync <OperationCanceledException>(async() => res = await dataPointIterator.ToArrayAsync(cts.Token));
CollectionAssert.AreEqual(expected, actual);
Assert.IsNull(res);
}
public void Cancellation_after_two_items___OK()
{
var sut = new NoCompression();
var data = RawDataForTrendAsync();
var expected = RawDataForTrend().Take(2).ToList();
var cts = new CancellationTokenSource();
var actual = new List <DataPoint>();
int idx = 0;
Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await foreach (DataPoint dp in sut.ProcessAsync(data).WithCancellation(cts.Token))
{
actual.Add(dp);
idx++;
if (idx == 2)
{
cts.Cancel();
}
}
});
CollectionAssert.AreEqual(actual, expected);
}
public void Cloning_iterates_over_fresh_set()
{
var sut = new NoCompression();
var data = KnownSequence().ToArray().Select(dp => dp);
var expected = KnownSequence().ToArray();
var filter = sut.Process(data);
var iterator = filter.GetEnumerator();
iterator.MoveNext();
iterator = filter.Clone().GetEnumerator();
Assert.Multiple(() =>
{
int step = 0;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
});
}
static void Main(string[] args)
{
var isPix = args[0] == "-p";
ICompressor compressor;
switch (args[1])
{
case "-l":
compressor = new LZ4Compressor();
break;
case "-s":
compressor = new SnappyCompressor();
break;
default:
compressor = new NoCompression();
break;
}
if (isPix)
{
new PixServer(compressor).Start();
}
else
{
new LiteServer(compressor).Start();
}
}
public void Known_sequence_as_array___correct_result()
{
var sut = new NoCompression();
var data = KnownSequence().ToArray();
var iterator = sut.Process(data).GetEnumerator();
var expected = KnownSequence().ToArray();
Assert.Multiple(() =>
{
int step = 0;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
});
}
public async Task Empty_IAsyncEnumerable___empty_result()
{
var sut = new NoCompression();
var data = EmptyAsync();
var iterator = sut.ProcessAsync(data).GetAsyncEnumerator();
Assert.IsFalse(await iterator.MoveNextAsync());
}
public void Empty_IEnumerable___empty_result()
{
var sut = new NoCompression();
var data = Empty();
var iterator = sut.Process(data).GetEnumerator();
Assert.IsFalse(iterator.MoveNext());
}
public void MoveNext_without_GetEnumerator___throws_InvalidOperation()
{
var sut = new NoCompression();
var data = RawDataForTrend();
var iterator = sut.Process(data);
Assert.Throws <InvalidOperationException>(() => iterator.MoveNext());
}
public void Data_IList_with_maxDeltaX___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDelta().ToList().AsReadOnly();
var expected = RawDataForMaxDelta().ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_given_as_IList___OK()
{
var sut = new NoCompression();
var data = RawDataForTrend().ToList().AsReadOnly();
var expected = RawDataForTrend().ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDeltaAsync();
var expected = RawDataForMaxDelta().ToList();
var actual = await sut.ProcessAsync(data).ToArrayAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_given_as_IAsyncEnumerable___OK()
{
var sut = new NoCompression();
var data = RawDataForTrendAsync();
var expected = RawDataForTrend().ToList();
var actual = await sut.ProcessAsync(data).ToArrayAsync();
CollectionAssert.AreEqual(expected, actual);
}
public void One_DataPoint_IEnumerable___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDelta().Take(1);
var expected = RawDataForMaxDelta().Take(1).ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_IList___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDelta().Take(2).ToList().AsReadOnly();
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
private void BenchmarkCompressionSpeed()
{
using (Bitmap bmpScreenCapture = new Bitmap(Screen.PrimaryScreen.Bounds.Width,
Screen.PrimaryScreen.Bounds.Height))
{
using (Graphics g = Graphics.FromImage(bmpScreenCapture))
{
g.CopyFromScreen(Screen.PrimaryScreen.Bounds.X,
Screen.PrimaryScreen.Bounds.Y,
0, 0,
bmpScreenCapture.Size,
CopyPixelOperation.SourceCopy);
}
using (var jpgCompressor = new JpgCompression(70))
{
for (int i = 0; i < 5; i++)
{
var sw = Stopwatch.StartNew();
GC.Collect();
GC.WaitForPendingFinalizers();
using (var outStream = new MemoryStream(10000))
{
jpgCompressor.Compress(bmpScreenCapture, outStream);
var data = outStream.ToArray();
Debug.Print("Managed JPG: Time neeeded: " + sw.ElapsedMilliseconds + ", size: " + data.Length);
}
}
}
using (var turboJpg = new NoCompression())
{
turboJpg.Quality = 70;
var lockBits =
bmpScreenCapture.LockBits(new Rectangle(0, 0, bmpScreenCapture.Width, bmpScreenCapture.Height),
ImageLockMode.ReadOnly, bmpScreenCapture.PixelFormat);
for (int i = 0; i < 5; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
var sw = Stopwatch.StartNew();
var data = turboJpg.Compress(lockBits.Scan0, lockBits.Stride,
new System.Drawing.Size(lockBits.Width, lockBits.Height), lockBits.PixelFormat);
Debug.Print("LZF: Time neeeded: " + sw.ElapsedMilliseconds + ", size: " + data.Length);
}
bmpScreenCapture.UnlockBits(lockBits);
}
}
}
public void Data_given_as_List___OK()
{
var sut = new NoCompression();
var data = RawDataForTrend().ToList();
var expected = RawDataForTrend().ToList();
var actual = new List<DataPoint>();
foreach (DataPoint dp in sut.Process(data))
actual.Add(dp);
CollectionAssert.AreEqual(expected, actual);
}
public void One_DataPoint_IEnumerable___OK()
{
var sut = new NoCompression();
var data = KnownSequence().Take(1);
var expected = KnownSequence().Take(1).ToList();
var actual = new List<DataPoint>();
foreach (DataPoint dp in sut.Process(data))
actual.Add(dp);
CollectionAssert.AreEqual(expected, actual);
}
public void Data_IList_with_maxDeltaX___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDelta().ToList().AsReadOnly();
var expected = RawDataForMaxDelta().ToList();
var actual = new List<DataPoint>();
foreach (DataPoint dp in sut.Process(data))
actual.Add(dp);
CollectionAssert.AreEqual(expected, actual);
}
public async Task Empty_IAsyncEnumerable_foreach___empty_result()
{
var sut = new NoCompression();
var data = EmptyAsync();
int count = 0;
await foreach (DataPoint db in sut.ProcessAsync(data))
{
count++;
}
Assert.AreEqual(0, count);
}
public void Empty_IEnumerable_foreach___empty_result()
{
var sut = new NoCompression();
var data = Empty();
int count = 0;
foreach (DataPoint dp in sut.Process(data))
{
count++;
}
Assert.AreEqual(0, count);
}
public void Two_DataPoint_IList___OK()
{
var sut = new NoCompression();
var data = KnownSequence().Take(2).ToList().AsReadOnly();
var expected = KnownSequence().Take(2).ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_List___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDelta().Take(2).ToList();
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK()
{
var sut = new NoCompression();
var data = RawDataForMaxDeltaAsync();
var expected = RawDataForMaxDelta().ToList();
var actual = new List <DataPoint>();
await foreach (DataPoint dp in sut.ProcessAsync(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Known_sequence_as_array_foreach___correct_result()
{
var sut = new NoCompression();
var data = KnownSequence().ToArray();
var result = sut.Process(data);
var expected = KnownSequence().ToArray();
var actual = new List <DataPoint>();
foreach (DataPoint dp in result)
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void List_iterated_and_ToList___OK()
{
var sut = new NoCompression();
var data = RawDataForTrend().ToList();
var expected = RawDataForTrend().ToList();
DataPointIterator dataPointIterator = sut.Process(data);
DataPointIterator enumerator = dataPointIterator.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
var actual = dataPointIterator.ToList();
CollectionAssert.AreEqual(expected, actual);
}
public async Task IAsyncEnumerable_iterated_and_ToArray___OK()
{
var sut = new NoCompression();
var data = RawDataForTrendAsync();
var expected = RawDataForTrend().ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var enumerator = dataPointIterator.GetAsyncEnumerator();
await enumerator.MoveNextAsync();
await enumerator.MoveNextAsync();
var actual = await dataPointIterator.ToArrayAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Known_sequence_foreach___correct_result()
{
var sut = new NoCompression();
var data = KnownSequenceAsync();
var result = sut.ProcessAsync(data);
var expected = new List <DataPoint>();
var actual = new List <DataPoint>();
await foreach (DataPoint dp in KnownSequenceAsync())
{
expected.Add(dp);
}
await foreach (DataPoint dp in result)
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public async Task Known_sequence___correct_result()
{
var sut = new NoCompression();
var data = KnownSequenceAsync();
var iterator = sut.ProcessAsync(data).GetAsyncEnumerator();
var expected = new List <DataPoint>();
await foreach (DataPoint dp in KnownSequenceAsync())
{
expected.Add(dp);
}
Assert.Multiple(async() =>
{
await iterator.MoveNextAsync();
Assert.AreEqual(expected[0], iterator.Current);
await iterator.MoveNextAsync();
Assert.AreEqual(expected[1], iterator.Current);
await iterator.MoveNextAsync();
Assert.AreEqual(expected[2], iterator.Current);
});
}
static void Main(string[] args)
{
var isPix = args[0] == "-p";
var rooms = args.Length == 3 ? int.Parse(args[2]) : 10;
ICompressor compressor;
switch (args[1])
{
case "-l":
compressor = new LZ4Compressor();
break;
case "-s":
compressor = new SnappyCompressor();
break;
default:
compressor = new NoCompression();
break;
}
for (var i = 0; i < rooms * 12; i++)
{
if (isPix)
{
Task.Run((Action) new PixClient(compressor).Start);
}
else
{
Task.Run((Action) new LiteClient(compressor).Start);
}
}
Console.ReadLine();
}
/// <summary>
/// Extracts data from a Brutal Legend package.
/// </summary>
/// <param name="HeaderFile">The *.~h Header file path</param>
/// <param name="DataFile">The ~.~p Data file path</param>
/// <param name="OutFolder">The output folder</param>
/// <returns>False if header file is invalid, true otherwise</returns>
public static bool Extract(string HeaderFile, string DataFile, string OutFolder)
{
FileStream Header = new FileStream(HeaderFile, FileMode.Open);
FileStream Data = new FileStream(DataFile, FileMode.Open);
EndianBinaryReader Reader = new EndianBinaryReader(Header, Endian.Big);
if (StringUtilities.ReadASCIIString(Header, 4) != "dfpf")
{
return(false);
}
Header.Seek(0x14, SeekOrigin.Begin);
uint StringsTableOffset = Reader.ReadUInt32();
uint StringsTableFlags = Reader.ReadUInt32();
uint StringsTableLength = Reader.ReadUInt32();
uint FilesCount = Reader.ReadUInt32();
Header.Seek(0x18, SeekOrigin.Current);
uint FilesTableOffset = Reader.ReadUInt32();
for (int Index = 0; Index < FilesCount; Index++)
{
Header.Seek(FilesTableOffset + Index * 0x10, SeekOrigin.Begin);
//Lengths
uint DecompressedLength = Reader.ReadUInt24();
uint LengthDifference = (uint)(Reader.ReadUInt16() << 1) | ((DecompressedLength & 1) << 17); //Probably for "obfuscation"
uint CompressedLength = Reader.ReadUInt24();
LengthDifference |= CompressedLength >> 23;
DecompressedLength = (DecompressedLength >> 1) + LengthDifference;
CompressedLength = (CompressedLength & 0x7fffff) >> 1;
//Offsets
uint DataOffset = Reader.ReadUInt24() << 5;
byte DataFormat = Reader.ReadByte();
DataOffset |= (uint)(DataFormat & 0xf8) >> 3;
DataFormat &= 7;
uint NameOffset = (Reader.ReadUInt24() >> 3) + StringsTableOffset;
byte Flags = Reader.ReadByte();
Header.Seek(NameOffset, SeekOrigin.Begin);
string FileName = StringUtilities.ReadASCIIString(Header);
if (OnStatusReport != null)
{
BrutalStatusReport Report = new BrutalStatusReport();
Report.Status = "Extracting " + FileName + "...";
Report.ProcessedFiles = Index;
Report.TotalFiles = (int)FilesCount;
OnStatusReport(null, Report);
}
Data.Seek(DataOffset, SeekOrigin.Begin);
byte[] Buffer = new byte[CompressedLength];
Data.Read(Buffer, 0, Buffer.Length);
ICompression Decompressor;
switch ((CompressionType)((Flags >> 1) & 3))
{
case CompressionType.None: Decompressor = new NoCompression(); break;
case CompressionType.ZLib: Decompressor = new ZLib(); break;
case CompressionType.LZX: Decompressor = new LZX(); break;
default: throw new Exception("Unknown compression!");
}
Buffer = Decompressor.Decompress(Buffer, DecompressedLength);
string FullName = Path.Combine(OutFolder, FileName);
string DirName = Path.GetDirectoryName(FullName);
if (!Directory.Exists(DirName))
{
Directory.CreateDirectory(DirName);
}
File.WriteAllBytes(FullName + ".bin", Buffer);
}
Header.Close();
Data.Close();
return(true);
}
