package SevenZip;

import java.io.ByteArrayOutputStream;

import java.io.ByteArrayInputStream;

import java.io.IOException;

public class LzmaBench

{

static final int kAdditionalSize = (1 << 21);

static final int kCompressedAdditionalSize = (1 << 10);

static class CRandomGenerator

{

int A1;

int A2;

public CRandomGenerator() { Init(); }

public void Init() { A1 = 362436069; A2 = 521288629; }

public int GetRnd()

{

return

((A1 = 36969 * (A1 & 0xffff) + (A1 >>> 16)) << 16) ^

((A2 = 18000 * (A2 & 0xffff) + (A2 >>> 16)));

}

};

static class CBitRandomGenerator

{

CRandomGenerator RG = new CRandomGenerator();

int Value;

int NumBits;

public void Init()

{

Value = 0;

NumBits = 0;

}

public int GetRnd(int numBits)

{

int result;

if (NumBits > numBits)

{

result = Value & ((1 << numBits) - 1);

Value >>>= numBits;

NumBits -= numBits;

return result;

}

numBits -= NumBits;

result = (Value << numBits);

Value = RG.GetRnd();

result |= Value & (((int)1 << numBits) - 1);

Value >>>= numBits;

NumBits = 32 - numBits;

return result;

}

};

static class CBenchRandomGenerator

{

CBitRandomGenerator RG = new CBitRandomGenerator();

int Pos;

int Rep0;

public int BufferSize;

public byte[] Buffer = null;

public CBenchRandomGenerator() { }

public void Set(int bufferSize)

{

Buffer = new byte[bufferSize];

Pos = 0;

BufferSize = bufferSize;

}

int GetRndBit() { return RG.GetRnd(1); }

int GetLogRandBits(int numBits)

{

int len = RG.GetRnd(numBits);

return RG.GetRnd((int)len);

}

int GetOffset()

{

if (GetRndBit() == 0)

return GetLogRandBits(4);

return (GetLogRandBits(4) << 10) | RG.GetRnd(10);

}

int GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }

int GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }

public void Generate()

{

RG.Init();

Rep0 = 1;

while (Pos < BufferSize)

{

if (GetRndBit() == 0 || Pos < 1)

Buffer[Pos++] = (byte)(RG.GetRnd(8));

else

{

int len;

if (RG.GetRnd(3) == 0)

len = 1 + GetLen1();

else

{

do

Rep0 = GetOffset();

while (Rep0 >= Pos);

Rep0++;

len = 2 + GetLen2();

}

for (int i = 0; i < len && Pos < BufferSize; i++, Pos++)

Buffer[Pos] = Buffer[Pos - Rep0];

}

}

}

};

static class CrcOutStream extends java.io.OutputStream

{

public CRC CRC = new CRC();

public void Init()

{

CRC.Init();

}

public int GetDigest()

{

return CRC.GetDigest();

}

public void write(byte[] b)

{

CRC.Update(b);

}

public void write(byte[] b, int off, int len)

{

CRC.Update(b, off, len);

}

public void write(int b)

{

CRC.UpdateByte(b);

}

};

static class MyOutputStream extends java.io.OutputStream

{

byte[] _buffer;

int _size;

int _pos;

public MyOutputStream(byte[] buffer)

{

_buffer = buffer;

_size = _buffer.length;

}

public void reset()

{

_pos = 0;

}

public void write(int b) throws IOException

{

if (_pos >= _size)

throw new IOException("Error");

_buffer[_pos++] = (byte)b;

}

public int size()

{

return _pos;

}

};

static class MyInputStream extends java.io.InputStream

{

byte[] _buffer;

int _size;

int _pos;

public MyInputStream(byte[] buffer, int size)

{

_buffer = buffer;

_size = size;

}

public void reset()

{

_pos = 0;

}

public int read()

{

if (_pos >= _size)

return -1;

return _buffer[_pos++] & 0xFF;

}

};

static class CProgressInfo implements ICodeProgress

{

public long ApprovedStart;

public long InSize;

public long Time;

public void Init()

{ InSize = 0; }

public void SetProgress(long inSize, long outSize)

{

if (inSize >= ApprovedStart && InSize == 0)

{

Time = System.currentTimeMillis();

InSize = inSize;

}

}

}

static final int kSubBits = 8;

static int GetLogSize(int size)

{

for (int i = kSubBits; i < 32; i++)

for (int j = 0; j < (1 << kSubBits); j++)

if (size <= ((1) << i) + (j << (i - kSubBits)))

return (i << kSubBits) + j;

return (32 << kSubBits);

}

static long MyMultDiv64(long value, long elapsedTime)

{

long freq = 1000; // ms

long elTime = elapsedTime;

while (freq > 1000000)

{

freq >>>= 1;

elTime >>>= 1;

}

if (elTime == 0)

elTime = 1;

return value * freq / elTime;

}

static long GetCompressRating(int dictionarySize, long elapsedTime, long size)

{

long t = GetLogSize(dictionarySize) - (18 << kSubBits);

long numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));

long numCommands = (long)(size) * numCommandsForOne;

return MyMultDiv64(numCommands, elapsedTime);

}

static long GetDecompressRating(long elapsedTime, long outSize, long inSize)

{

long numCommands = inSize * 220 + outSize * 20;

return MyMultDiv64(numCommands, elapsedTime);

}

static long GetTotalRating(

int dictionarySize,

long elapsedTimeEn, long sizeEn,

long elapsedTimeDe,

long inSizeDe, long outSizeDe)

{

return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +

GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;

}

static void PrintValue(long v)

{

String s = "";

s += v;

for (int i = 0; i + s.length() < 6; i++)

System.out.print(" ");

System.out.print(s);

}

static void PrintRating(long rating)

{

PrintValue(rating / 1000000);

System.out.print(" MIPS");

}

static void PrintResults(

int dictionarySize,

long elapsedTime,

long size,

boolean decompressMode, long secondSize)

{

long speed = MyMultDiv64(size, elapsedTime);

PrintValue(speed / 1024);

System.out.print(" KB/s ");

long rating;

if (decompressMode)

rating = GetDecompressRating(elapsedTime, size, secondSize);

else

rating = GetCompressRating(dictionarySize, elapsedTime, size);

PrintRating(rating);

}

static public int LzmaBenchmark(int numIterations, int dictionarySize) throws Exception

{

if (numIterations <= 0)

return 0;

if (dictionarySize < (1 << 18))

{

System.out.println("\nError: dictionary size for benchmark must be >= 18 (256 KB)");

return 1;

}

System.out.print("\n Compressing Decompressing\n\n");

SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();

SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();

if (!encoder.SetDictionarySize(dictionarySize))

throw new Exception("Incorrect dictionary size");

int kBufferSize = dictionarySize + kAdditionalSize;

int kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;

ByteArrayOutputStream propStream = new ByteArrayOutputStream();

encoder.WriteCoderProperties(propStream);

byte[] propArray = propStream.toByteArray();

decoder.SetDecoderProperties(propArray);

CBenchRandomGenerator rg = new CBenchRandomGenerator();

rg.Set(kBufferSize);

rg.Generate();

CRC crc = new CRC();

crc.Init();

crc.Update(rg.Buffer, 0, rg.BufferSize);

CProgressInfo progressInfo = new CProgressInfo();

progressInfo.ApprovedStart = dictionarySize;

long totalBenchSize = 0;

long totalEncodeTime = 0;

long totalDecodeTime = 0;

long totalCompressedSize = 0;

MyInputStream inStream = new MyInputStream(rg.Buffer, rg.BufferSize);

byte[] compressedBuffer = new byte[kCompressedBufferSize];

MyOutputStream compressedStream = new MyOutputStream(compressedBuffer);

CrcOutStream crcOutStream = new CrcOutStream();

MyInputStream inputCompressedStream = null;

int compressedSize = 0;

for (int i = 0; i < numIterations; i++)

{

progressInfo.Init();

inStream.reset();

compressedStream.reset();

encoder.Code(inStream, compressedStream, -1, -1, progressInfo);

long encodeTime = System.currentTimeMillis() - progressInfo.Time;

if (i == 0)

{

compressedSize = compressedStream.size();

inputCompressedStream = new MyInputStream(compressedBuffer, compressedSize);

}

else if (compressedSize != compressedStream.size())

throw (new Exception("Encoding error"));

if (progressInfo.InSize == 0)

throw (new Exception("Internal ERROR 1282"));

long decodeTime = 0;

for (int j = 0; j < 2; j++)

{

inputCompressedStream.reset();

crcOutStream.Init();

long outSize = kBufferSize;

long startTime = System.currentTimeMillis();

if (!decoder.Code(inputCompressedStream, crcOutStream, outSize))

throw (new Exception("Decoding Error"));;

decodeTime = System.currentTimeMillis() - startTime;

if (crcOutStream.GetDigest() != crc.GetDigest())

throw (new Exception("CRC Error"));

}

long benchSize = kBufferSize - (long)progressInfo.InSize;

PrintResults(dictionarySize, encodeTime, benchSize, false, 0);

System.out.print(" ");

PrintResults(dictionarySize, decodeTime, kBufferSize, true, compressedSize);

System.out.println();

totalBenchSize += benchSize;

totalEncodeTime += encodeTime;

totalDecodeTime += decodeTime;

totalCompressedSize += compressedSize;

}

System.out.println("---------------------------------------------------");

PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);

System.out.print(" ");

PrintResults(dictionarySize, totalDecodeTime,

kBufferSize * (long)numIterations, true, totalCompressedSize);

System.out.println(" Average");

return 0;

}

}