Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 392 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java b/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java
new file mode 100644
index 0000000000..cceda24da2
--- /dev/null
+++ b/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java
@@ -0,0 +1,392 @@
+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;

+	}

+}