diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
7 files changed, 955 insertions, 0 deletions
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs new file mode 100644 index 0000000000..8aa446267a --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs @@ -0,0 +1,364 @@ +using System;
+using System.IO;
+namespace SevenZip
+{
+ using CommandLineParser;
+
+ public class CDoubleStream: Stream
+ {
+ public System.IO.Stream s1;
+ public System.IO.Stream s2;
+ public int fileIndex;
+ public long skipSize;
+
+ public override bool CanRead { get { return true; }}
+ public override bool CanWrite { get { return false; }}
+ public override bool CanSeek { get { return false; }}
+ public override long Length { get { return s1.Length + s2.Length - skipSize; } }
+ public override long Position
+ {
+ get { return 0; }
+ set { }
+ }
+ public override void Flush() { }
+ public override int Read(byte[] buffer, int offset, int count)
+ {
+ int numTotal = 0;
+ while (count > 0)
+ {
+ if (fileIndex == 0)
+ {
+ int num = s1.Read(buffer, offset, count);
+ offset += num;
+ count -= num;
+ numTotal += num;
+ if (num == 0)
+ fileIndex++;
+ }
+ if (fileIndex == 1)
+ {
+ numTotal += s2.Read(buffer, offset, count);
+ return numTotal;
+ }
+ }
+ return numTotal;
+ }
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ throw (new Exception("can't Write"));
+ }
+ public override long Seek(long offset, System.IO.SeekOrigin origin)
+ {
+ throw (new Exception("can't Seek"));
+ }
+ public override void SetLength(long value)
+ {
+ throw (new Exception("can't SetLength"));
+ }
+ }
+
+ class LzmaAlone
+ {
+ enum Key
+ {
+ Help1 = 0,
+ Help2,
+ Mode,
+ Dictionary,
+ FastBytes,
+ LitContext,
+ LitPos,
+ PosBits,
+ MatchFinder,
+ EOS,
+ StdIn,
+ StdOut,
+ Train
+ };
+
+ static void PrintHelp()
+ {
+ System.Console.WriteLine("\nUsage: LZMA <e|d> [<switches>...] inputFile outputFile\n" +
+ " e: encode file\n" +
+ " d: decode file\n" +
+ " b: Benchmark\n" +
+ "<Switches>\n" +
+ // " -a{N}: set compression mode - [0, 1], default: 1 (max)\n" +
+ " -d{N}: set dictionary - [0, 29], default: 23 (8MB)\n" +
+ " -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +
+ " -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +
+ " -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +
+ " -pb{N}: set number of pos bits - [0, 4], default: 2\n" +
+ " -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +
+ " -eos: write End Of Stream marker\n"
+ // + " -si: read data from stdin\n"
+ // + " -so: write data to stdout\n"
+ );
+ }
+
+ static bool GetNumber(string s, out Int32 v)
+ {
+ v = 0;
+ for (int i = 0; i < s.Length; i++)
+ {
+ char c = s[i];
+ if (c < '0' || c > '9')
+ return false;
+ v *= 10;
+ v += (Int32)(c - '0');
+ }
+ return true;
+ }
+
+ static int IncorrectCommand()
+ {
+ throw (new Exception("Command line error"));
+ // System.Console.WriteLine("\nCommand line error\n");
+ // return 1;
+ }
+ static int Main2(string[] args)
+ {
+ System.Console.WriteLine("\nLZMA# 4.61 2008-11-23\n");
+
+ if (args.Length == 0)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ SwitchForm[] kSwitchForms = new SwitchForm[13];
+ int sw = 0;
+ kSwitchForms[sw++] = new SwitchForm("?", SwitchType.Simple, false);
+ kSwitchForms[sw++] = new SwitchForm("H", SwitchType.Simple, false);
+ kSwitchForms[sw++] = new SwitchForm("A", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("D", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("FB", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("LC", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("LP", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("PB", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("MF", SwitchType.UnLimitedPostString, false, 1);
+ kSwitchForms[sw++] = new SwitchForm("EOS", SwitchType.Simple, false);
+ kSwitchForms[sw++] = new SwitchForm("SI", SwitchType.Simple, false);
+ kSwitchForms[sw++] = new SwitchForm("SO", SwitchType.Simple, false);
+ kSwitchForms[sw++] = new SwitchForm("T", SwitchType.UnLimitedPostString, false, 1);
+
+
+ Parser parser = new Parser(sw);
+ try
+ {
+ parser.ParseStrings(kSwitchForms, args);
+ }
+ catch
+ {
+ return IncorrectCommand();
+ }
+
+ if (parser[(int)Key.Help1].ThereIs || parser[(int)Key.Help2].ThereIs)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ System.Collections.ArrayList nonSwitchStrings = parser.NonSwitchStrings;
+
+ int paramIndex = 0;
+ if (paramIndex >= nonSwitchStrings.Count)
+ return IncorrectCommand();
+ string command = (string)nonSwitchStrings[paramIndex++];
+ command = command.ToLower();
+
+ bool dictionaryIsDefined = false;
+ Int32 dictionary = 1 << 21;
+ if (parser[(int)Key.Dictionary].ThereIs)
+ {
+ Int32 dicLog;
+ if (!GetNumber((string)parser[(int)Key.Dictionary].PostStrings[0], out dicLog))
+ IncorrectCommand();
+ dictionary = (Int32)1 << dicLog;
+ dictionaryIsDefined = true;
+ }
+ string mf = "bt4";
+ if (parser[(int)Key.MatchFinder].ThereIs)
+ mf = (string)parser[(int)Key.MatchFinder].PostStrings[0];
+ mf = mf.ToLower();
+
+ if (command == "b")
+ {
+ const Int32 kNumDefaultItereations = 10;
+ Int32 numIterations = kNumDefaultItereations;
+ if (paramIndex < nonSwitchStrings.Count)
+ if (!GetNumber((string)nonSwitchStrings[paramIndex++], out numIterations))
+ numIterations = kNumDefaultItereations;
+ return LzmaBench.LzmaBenchmark(numIterations, (UInt32)dictionary);
+ }
+
+ string train = "";
+ if (parser[(int)Key.Train].ThereIs)
+ train = (string)parser[(int)Key.Train].PostStrings[0];
+
+ bool encodeMode = false;
+ if (command == "e")
+ encodeMode = true;
+ else if (command == "d")
+ encodeMode = false;
+ else
+ IncorrectCommand();
+
+ bool stdInMode = parser[(int)Key.StdIn].ThereIs;
+ bool stdOutMode = parser[(int)Key.StdOut].ThereIs;
+
+ Stream inStream = null;
+ if (stdInMode)
+ {
+ throw (new Exception("Not implemeted"));
+ }
+ else
+ {
+ if (paramIndex >= nonSwitchStrings.Count)
+ IncorrectCommand();
+ string inputName = (string)nonSwitchStrings[paramIndex++];
+ inStream = new FileStream(inputName, FileMode.Open, FileAccess.Read);
+ }
+
+ FileStream outStream = null;
+ if (stdOutMode)
+ {
+ throw (new Exception("Not implemeted"));
+ }
+ else
+ {
+ if (paramIndex >= nonSwitchStrings.Count)
+ IncorrectCommand();
+ string outputName = (string)nonSwitchStrings[paramIndex++];
+ outStream = new FileStream(outputName, FileMode.Create, FileAccess.Write);
+ }
+
+ FileStream trainStream = null;
+ if (train.Length != 0)
+ trainStream = new FileStream(train, FileMode.Open, FileAccess.Read);
+
+ if (encodeMode)
+ {
+ if (!dictionaryIsDefined)
+ dictionary = 1 << 23;
+
+ Int32 posStateBits = 2;
+ Int32 litContextBits = 3; // for normal files
+ // UInt32 litContextBits = 0; // for 32-bit data
+ Int32 litPosBits = 0;
+ // UInt32 litPosBits = 2; // for 32-bit data
+ Int32 algorithm = 2;
+ Int32 numFastBytes = 128;
+
+ bool eos = parser[(int)Key.EOS].ThereIs || stdInMode;
+
+ if (parser[(int)Key.Mode].ThereIs)
+ if (!GetNumber((string)parser[(int)Key.Mode].PostStrings[0], out algorithm))
+ IncorrectCommand();
+
+ if (parser[(int)Key.FastBytes].ThereIs)
+ if (!GetNumber((string)parser[(int)Key.FastBytes].PostStrings[0], out numFastBytes))
+ IncorrectCommand();
+ if (parser[(int)Key.LitContext].ThereIs)
+ if (!GetNumber((string)parser[(int)Key.LitContext].PostStrings[0], out litContextBits))
+ IncorrectCommand();
+ if (parser[(int)Key.LitPos].ThereIs)
+ if (!GetNumber((string)parser[(int)Key.LitPos].PostStrings[0], out litPosBits))
+ IncorrectCommand();
+ if (parser[(int)Key.PosBits].ThereIs)
+ if (!GetNumber((string)parser[(int)Key.PosBits].PostStrings[0], out posStateBits))
+ IncorrectCommand();
+
+ CoderPropID[] propIDs =
+ {
+ CoderPropID.DictionarySize,
+ CoderPropID.PosStateBits,
+ CoderPropID.LitContextBits,
+ CoderPropID.LitPosBits,
+ CoderPropID.Algorithm,
+ CoderPropID.NumFastBytes,
+ CoderPropID.MatchFinder,
+ CoderPropID.EndMarker
+ };
+ object[] properties =
+ {
+ (Int32)(dictionary),
+ (Int32)(posStateBits),
+ (Int32)(litContextBits),
+ (Int32)(litPosBits),
+ (Int32)(algorithm),
+ (Int32)(numFastBytes),
+ mf,
+ eos
+ };
+
+ Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
+ encoder.SetCoderProperties(propIDs, properties);
+ encoder.WriteCoderProperties(outStream);
+ Int64 fileSize;
+ if (eos || stdInMode)
+ fileSize = -1;
+ else
+ fileSize = inStream.Length;
+ for (int i = 0; i < 8; i++)
+ outStream.WriteByte((Byte)(fileSize >> (8 * i)));
+ if (trainStream != null)
+ {
+ CDoubleStream doubleStream = new CDoubleStream();
+ doubleStream.s1 = trainStream;
+ doubleStream.s2 = inStream;
+ doubleStream.fileIndex = 0;
+ inStream = doubleStream;
+ long trainFileSize = trainStream.Length;
+ doubleStream.skipSize = 0;
+ if (trainFileSize > dictionary)
+ doubleStream.skipSize = trainFileSize - dictionary;
+ trainStream.Seek(doubleStream.skipSize, SeekOrigin.Begin);
+ encoder.SetTrainSize((uint)(trainFileSize - doubleStream.skipSize));
+ }
+ encoder.Code(inStream, outStream, -1, -1, null);
+ }
+ else if (command == "d")
+ {
+ byte[] properties = new byte[5];
+ if (inStream.Read(properties, 0, 5) != 5)
+ throw (new Exception("input .lzma is too short"));
+ Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
+ decoder.SetDecoderProperties(properties);
+ if (trainStream != null)
+ {
+ if (!decoder.Train(trainStream))
+ throw (new Exception("can't train"));
+ }
+ long outSize = 0;
+ for (int i = 0; i < 8; i++)
+ {
+ int v = inStream.ReadByte();
+ if (v < 0)
+ throw (new Exception("Can't Read 1"));
+ outSize |= ((long)(byte)v) << (8 * i);
+ }
+ long compressedSize = inStream.Length - inStream.Position;
+ decoder.Code(inStream, outStream, compressedSize, outSize, null);
+ }
+ else
+ throw (new Exception("Command Error"));
+ return 0;
+ }
+
+ [STAThread]
+ static int Main(string[] args)
+ {
+ try
+ {
+ return Main2(args);
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("{0} Caught exception #1.", e);
+ // throw e;
+ return 1;
+ }
+ }
+ }
+}
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj new file mode 100644 index 0000000000..ceb7073504 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj @@ -0,0 +1,90 @@ +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <PropertyGroup>
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+ <ProductVersion>8.0.50727</ProductVersion>
+ <SchemaVersion>2.0</SchemaVersion>
+ <ProjectGuid>{CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}</ProjectGuid>
+ <OutputType>Exe</OutputType>
+ <RootNamespace>LzmaAlone</RootNamespace>
+ <AssemblyName>Lzma#</AssemblyName>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+ <DebugSymbols>true</DebugSymbols>
+ <DebugType>full</DebugType>
+ <Optimize>false</Optimize>
+ <OutputPath>.\bin\Debug\</OutputPath>
+ <DefineConstants>DEBUG;TRACE</DefineConstants>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+ <DebugSymbols>false</DebugSymbols>
+ <Optimize>true</Optimize>
+ <OutputPath>.\bin\Release\</OutputPath>
+ <DefineConstants>TRACE</DefineConstants>
+ <PlatformTarget>AnyCPU</PlatformTarget>
+ </PropertyGroup>
+ <ItemGroup>
+ <Reference Include="System" />
+ <Reference Include="System.Data" />
+ <Reference Include="System.Xml" />
+ </ItemGroup>
+ <ItemGroup>
+ <Compile Include="..\..\Common\CommandLineParser.cs">
+ <Link>Common\CommandLineParser.cs</Link>
+ </Compile>
+ <Compile Include="..\..\Common\CRC.cs">
+ <Link>Common\CRC.cs</Link>
+ </Compile>
+ <Compile Include="..\..\ICoder.cs">
+ <Link>ICoder.cs</Link>
+ </Compile>
+ <Compile Include="..\LZ\IMatchFinder.cs">
+ <Link>LZ\IMatchFinder.cs</Link>
+ </Compile>
+ <Compile Include="..\LZ\LzBinTree.cs">
+ <Link>LZ\LzBinTree.cs</Link>
+ </Compile>
+ <Compile Include="..\LZ\LzInWindow.cs">
+ <Link>LZ\LzInWindow.cs</Link>
+ </Compile>
+ <Compile Include="..\LZ\LzOutWindow.cs">
+ <Link>LZ\LzOutWindow.cs</Link>
+ </Compile>
+ <Compile Include="..\LZMA\LzmaBase.cs">
+ <Link>LZMA\LzmaBase.cs</Link>
+ </Compile>
+ <Compile Include="..\LZMA\LzmaDecoder.cs">
+ <Link>LZMA\LzmaDecoder.cs</Link>
+ </Compile>
+ <Compile Include="..\LZMA\LzmaEncoder.cs">
+ <Link>LZMA\LzmaEncoder.cs</Link>
+ </Compile>
+ <Compile Include="..\RangeCoder\RangeCoder.cs">
+ <Link>RangeCoder\RangeCoder.cs</Link>
+ </Compile>
+ <Compile Include="..\RangeCoder\RangeCoderBit.cs">
+ <Link>RangeCoder\RangeCoderBit.cs</Link>
+ </Compile>
+ <Compile Include="..\RangeCoder\RangeCoderBitTree.cs">
+ <Link>RangeCoder\RangeCoderBitTree.cs</Link>
+ </Compile>
+ <Compile Include="LzmaAlone.cs">
+ <SubType>Code</SubType>
+ </Compile>
+ <Compile Include="LzmaBench.cs">
+ <SubType>Code</SubType>
+ </Compile>
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="Properties\Settings.cs">
+ <AutoGen>True</AutoGen>
+ <DependentUpon>Settings.settings</DependentUpon>
+ </Compile>
+ <None Include="Properties\Settings.settings">
+ <Generator>SettingsSingleFileGenerator</Generator>
+ <LastGenOutput>Settings.cs</LastGenOutput>
+ </None>
+ <AppDesigner Include="Properties\" />
+ </ItemGroup>
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
+</Project>
\ No newline at end of file diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln new file mode 100644 index 0000000000..a96ee3e433 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln @@ -0,0 +1,20 @@ +
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C# Express 2005
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LzmaAlone", "LzmaAlone.csproj", "{CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaBench.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaBench.cs new file mode 100644 index 0000000000..6a1ffe2460 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaBench.cs @@ -0,0 +1,340 @@ +// LzmaBench.cs
+
+using System;
+using System.IO;
+
+namespace SevenZip
+{
+ /// <summary>
+ /// LZMA Benchmark
+ /// </summary>
+ internal abstract class LzmaBench
+ {
+ const UInt32 kAdditionalSize = (6 << 20);
+ const UInt32 kCompressedAdditionalSize = (1 << 10);
+ const UInt32 kMaxLzmaPropSize = 10;
+
+ class CRandomGenerator
+ {
+ UInt32 A1;
+ UInt32 A2;
+ public CRandomGenerator() { Init(); }
+ public void Init() { A1 = 362436069; A2 = 521288629; }
+ public UInt32 GetRnd()
+ {
+ return
+ ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) ^
+ ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)));
+ }
+ };
+
+ class CBitRandomGenerator
+ {
+ CRandomGenerator RG = new CRandomGenerator();
+ UInt32 Value;
+ int NumBits;
+ public void Init()
+ {
+ Value = 0;
+ NumBits = 0;
+ }
+ public UInt32 GetRnd(int numBits)
+ {
+ UInt32 result;
+ if (NumBits > numBits)
+ {
+ result = Value & (((UInt32)1 << numBits) - 1);
+ Value >>= numBits;
+ NumBits -= numBits;
+ return result;
+ }
+ numBits -= NumBits;
+ result = (Value << numBits);
+ Value = RG.GetRnd();
+ result |= Value & (((UInt32)1 << numBits) - 1);
+ Value >>= numBits;
+ NumBits = 32 - numBits;
+ return result;
+ }
+ };
+
+ class CBenchRandomGenerator
+ {
+ CBitRandomGenerator RG = new CBitRandomGenerator();
+ UInt32 Pos;
+ UInt32 Rep0;
+
+ public UInt32 BufferSize;
+ public Byte[] Buffer = null;
+
+ public CBenchRandomGenerator() { }
+
+ public void Set(UInt32 bufferSize)
+ {
+ Buffer = new Byte[bufferSize];
+ Pos = 0;
+ BufferSize = bufferSize;
+ }
+ UInt32 GetRndBit() { return RG.GetRnd(1); }
+ UInt32 GetLogRandBits(int numBits)
+ {
+ UInt32 len = RG.GetRnd(numBits);
+ return RG.GetRnd((int)len);
+ }
+ UInt32 GetOffset()
+ {
+ if (GetRndBit() == 0)
+ return GetLogRandBits(4);
+ return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
+ }
+ UInt32 GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
+ UInt32 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
+ {
+ UInt32 len;
+ if (RG.GetRnd(3) == 0)
+ len = 1 + GetLen1();
+ else
+ {
+ do
+ Rep0 = GetOffset();
+ while (Rep0 >= Pos);
+ Rep0++;
+ len = 2 + GetLen2();
+ }
+ for (UInt32 i = 0; i < len && Pos < BufferSize; i++, Pos++)
+ Buffer[Pos] = Buffer[Pos - Rep0];
+ }
+ }
+ }
+ };
+
+ class CrcOutStream : System.IO.Stream
+ {
+ public CRC CRC = new CRC();
+ public void Init() { CRC.Init(); }
+ public UInt32 GetDigest() { return CRC.GetDigest(); }
+
+ public override bool CanRead { get { return false; } }
+ public override bool CanSeek { get { return false; } }
+ public override bool CanWrite { get { return true; } }
+ public override Int64 Length { get { return 0; } }
+ public override Int64 Position { get { return 0; } set { } }
+ public override void Flush() { }
+ public override long Seek(long offset, SeekOrigin origin) { return 0; }
+ public override void SetLength(long value) { }
+ public override int Read(byte[] buffer, int offset, int count) { return 0; }
+
+ public override void WriteByte(byte b)
+ {
+ CRC.UpdateByte(b);
+ }
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ CRC.Update(buffer, (uint)offset, (uint)count);
+ }
+ };
+
+ class CProgressInfo : ICodeProgress
+ {
+ public Int64 ApprovedStart;
+ public Int64 InSize;
+ public System.DateTime Time;
+ public void Init() { InSize = 0; }
+ public void SetProgress(Int64 inSize, Int64 outSize)
+ {
+ if (inSize >= ApprovedStart && InSize == 0)
+ {
+ Time = DateTime.UtcNow;
+ InSize = inSize;
+ }
+ }
+ }
+ const int kSubBits = 8;
+
+ static UInt32 GetLogSize(UInt32 size)
+ {
+ for (int i = kSubBits; i < 32; i++)
+ for (UInt32 j = 0; j < (1 << kSubBits); j++)
+ if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))
+ return (UInt32)(i << kSubBits) + j;
+ return (32 << kSubBits);
+ }
+
+ static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime)
+ {
+ UInt64 freq = TimeSpan.TicksPerSecond;
+ UInt64 elTime = elapsedTime;
+ while (freq > 1000000)
+ {
+ freq >>= 1;
+ elTime >>= 1;
+ }
+ if (elTime == 0)
+ elTime = 1;
+ return value * freq / elTime;
+ }
+
+ static UInt64 GetCompressRating(UInt32 dictionarySize, UInt64 elapsedTime, UInt64 size)
+ {
+ UInt64 t = GetLogSize(dictionarySize) - (18 << kSubBits);
+ UInt64 numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
+ UInt64 numCommands = (UInt64)(size) * numCommandsForOne;
+ return MyMultDiv64(numCommands, elapsedTime);
+ }
+
+ static UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 outSize, UInt64 inSize)
+ {
+ UInt64 numCommands = inSize * 220 + outSize * 20;
+ return MyMultDiv64(numCommands, elapsedTime);
+ }
+
+ static UInt64 GetTotalRating(
+ UInt32 dictionarySize,
+ UInt64 elapsedTimeEn, UInt64 sizeEn,
+ UInt64 elapsedTimeDe,
+ UInt64 inSizeDe, UInt64 outSizeDe)
+ {
+ return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
+ GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
+ }
+
+ static void PrintValue(UInt64 v)
+ {
+ string s = v.ToString();
+ for (int i = 0; i + s.Length < 6; i++)
+ System.Console.Write(" ");
+ System.Console.Write(s);
+ }
+
+ static void PrintRating(UInt64 rating)
+ {
+ PrintValue(rating / 1000000);
+ System.Console.Write(" MIPS");
+ }
+
+ static void PrintResults(
+ UInt32 dictionarySize,
+ UInt64 elapsedTime,
+ UInt64 size,
+ bool decompressMode, UInt64 secondSize)
+ {
+ UInt64 speed = MyMultDiv64(size, elapsedTime);
+ PrintValue(speed / 1024);
+ System.Console.Write(" KB/s ");
+ UInt64 rating;
+ if (decompressMode)
+ rating = GetDecompressRating(elapsedTime, size, secondSize);
+ else
+ rating = GetCompressRating(dictionarySize, elapsedTime, size);
+ PrintRating(rating);
+ }
+
+ static public int LzmaBenchmark(Int32 numIterations, UInt32 dictionarySize)
+ {
+ if (numIterations <= 0)
+ return 0;
+ if (dictionarySize < (1 << 18))
+ {
+ System.Console.WriteLine("\nError: dictionary size for benchmark must be >= 19 (512 KB)");
+ return 1;
+ }
+ System.Console.Write("\n Compressing Decompressing\n\n");
+
+ Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
+ Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
+
+
+ CoderPropID[] propIDs =
+ {
+ CoderPropID.DictionarySize,
+ };
+ object[] properties =
+ {
+ (Int32)(dictionarySize),
+ };
+
+ UInt32 kBufferSize = dictionarySize + kAdditionalSize;
+ UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
+
+ encoder.SetCoderProperties(propIDs, properties);
+ System.IO.MemoryStream propStream = new System.IO.MemoryStream();
+ encoder.WriteCoderProperties(propStream);
+ byte[] propArray = propStream.ToArray();
+
+ 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;
+
+ UInt64 totalBenchSize = 0;
+ UInt64 totalEncodeTime = 0;
+ UInt64 totalDecodeTime = 0;
+ UInt64 totalCompressedSize = 0;
+
+ MemoryStream inStream = new MemoryStream(rg.Buffer, 0, (int)rg.BufferSize);
+ MemoryStream compressedStream = new MemoryStream((int)kCompressedBufferSize);
+ CrcOutStream crcOutStream = new CrcOutStream();
+ for (Int32 i = 0; i < numIterations; i++)
+ {
+ progressInfo.Init();
+ inStream.Seek(0, SeekOrigin.Begin);
+ compressedStream.Seek(0, SeekOrigin.Begin);
+ encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
+ TimeSpan sp2 = DateTime.UtcNow - progressInfo.Time;
+ UInt64 encodeTime = (UInt64)sp2.Ticks;
+
+ long compressedSize = compressedStream.Position;
+ if (progressInfo.InSize == 0)
+ throw (new Exception("Internal ERROR 1282"));
+
+ UInt64 decodeTime = 0;
+ for (int j = 0; j < 2; j++)
+ {
+ compressedStream.Seek(0, SeekOrigin.Begin);
+ crcOutStream.Init();
+
+ decoder.SetDecoderProperties(propArray);
+ UInt64 outSize = kBufferSize;
+ System.DateTime startTime = DateTime.UtcNow;
+ decoder.Code(compressedStream, crcOutStream, 0, (Int64)outSize, null);
+ TimeSpan sp = (DateTime.UtcNow - startTime);
+ decodeTime = (ulong)sp.Ticks;
+ if (crcOutStream.GetDigest() != crc.GetDigest())
+ throw (new Exception("CRC Error"));
+ }
+ UInt64 benchSize = kBufferSize - (UInt64)progressInfo.InSize;
+ PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
+ System.Console.Write(" ");
+ PrintResults(dictionarySize, decodeTime, kBufferSize, true, (ulong)compressedSize);
+ System.Console.WriteLine();
+
+ totalBenchSize += benchSize;
+ totalEncodeTime += encodeTime;
+ totalDecodeTime += decodeTime;
+ totalCompressedSize += (ulong)compressedSize;
+ }
+ System.Console.WriteLine("---------------------------------------------------");
+ PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
+ System.Console.Write(" ");
+ PrintResults(dictionarySize, totalDecodeTime,
+ kBufferSize * (UInt64)numIterations, true, totalCompressedSize);
+ System.Console.WriteLine(" Average");
+ return 0;
+ }
+ }
+}
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..a394aee877 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs @@ -0,0 +1,29 @@ +#region Using directives
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+#endregion
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("LZMA#")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Igor Pavlov")]
+[assembly: AssemblyProduct("LZMA# SDK")]
+[assembly: AssemblyCopyright("Copyright @ Igor Pavlov 1999-2004")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("4.12.*")]
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs new file mode 100644 index 0000000000..efe4ee9af8 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs @@ -0,0 +1,70 @@ +//------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+// Runtime Version:2.0.40607.42
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+//------------------------------------------------------------------------------
+
+namespace LzmaAlone.Properties
+{
+ using System;
+ using System.IO;
+ using System.Resources;
+
+ /// <summary>
+ /// A strongly-typed resource class, for looking up localized strings, etc.
+ /// </summary>
+ // This class was auto-generated by the Strongly Typed Resource Builder
+ // class via a tool like ResGen or Visual Studio.NET.
+ // To add or remove a member, edit your .ResX file then rerun ResGen
+ // with the /str option, or rebuild your VS project.
+ class Resources
+ {
+
+ private static System.Resources.ResourceManager _resMgr;
+
+ private static System.Globalization.CultureInfo _resCulture;
+
+ /*FamANDAssem*/
+ internal Resources()
+ {
+ }
+
+ /// <summary>
+ /// Returns the cached ResourceManager instance used by this class.
+ /// </summary>
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+ public static System.Resources.ResourceManager ResourceManager
+ {
+ get
+ {
+ if ((_resMgr == null))
+ {
+ System.Resources.ResourceManager temp = new System.Resources.ResourceManager("Resources", typeof(Resources).Assembly);
+ _resMgr = temp;
+ }
+ return _resMgr;
+ }
+ }
+
+ /// <summary>
+ /// Overrides the current thread's CurrentUICulture property for all
+ /// resource lookups using this strongly typed resource class.
+ /// </summary>
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+ public static System.Globalization.CultureInfo Culture
+ {
+ get
+ {
+ return _resCulture;
+ }
+ set
+ {
+ _resCulture = value;
+ }
+ }
+ }
+}
diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs new file mode 100644 index 0000000000..1281fd2e09 --- /dev/null +++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs @@ -0,0 +1,42 @@ +//------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+// Runtime Version:2.0.40607.42
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+//------------------------------------------------------------------------------
+
+namespace LzmaAlone.Properties
+{
+ public partial class Settings : System.Configuration.ApplicationSettingsBase
+ {
+ private static Settings m_Value;
+
+ private static object m_SyncObject = new object();
+
+ public static Settings Value
+ {
+ get
+ {
+ if ((Settings.m_Value == null))
+ {
+ System.Threading.Monitor.Enter(Settings.m_SyncObject);
+ if ((Settings.m_Value == null))
+ {
+ try
+ {
+ Settings.m_Value = new Settings();
+ }
+ finally
+ {
+ System.Threading.Monitor.Exit(Settings.m_SyncObject);
+ }
+ }
+ }
+ return Settings.m_Value;
+ }
+ }
+ }
+}
|