Add m-esr52 at 52.6.0

5 files changed, 597 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h
new file mode 100644
index 000000000..9828bc4b9
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h
@@ -0,0 +1,205 @@
+// Compress/RangeCoder/RangeCoder.h

+

+#ifndef __COMPRESS_RANGECODER_H

+#define __COMPRESS_RANGECODER_H

+

+#include "../../Common/InBuffer.h"

+#include "../../Common/OutBuffer.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumTopBits = 24;

+const UInt32 kTopValue = (1 << kNumTopBits);

+

+class CEncoder

+{

+  UInt32 _cacheSize;

+  Byte _cache;

+public:

+  UInt64 Low;

+  UInt32 Range;

+  COutBuffer Stream;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Low = 0;

+    Range = 0xFFFFFFFF;

+    _cacheSize = 1;

+    _cache = 0;

+  }

+

+  void FlushData()

+  {

+    // Low += 1; 

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

+      ShiftLow();

+  }

+

+  HRESULT FlushStream() { return Stream.Flush();  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  void Encode(UInt32 start, UInt32 size, UInt32 total)

+  {

+    Low += start * (Range /= total);

+    Range *= size;

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  void ShiftLow()

+  {

+    if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0) 

+    {

+      Byte temp = _cache;

+      do

+      {

+        Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));

+        temp = 0xFF;

+      }

+      while(--_cacheSize != 0);

+      _cache = (Byte)((UInt32)Low >> 24);                      

+    } 

+    _cacheSize++;                               

+    Low = (UInt32)Low << 8;                           

+  }

+  

+  void EncodeDirectBits(UInt32 value, int numTotalBits)

+  {

+    for (int i = numTotalBits - 1; i >= 0; i--)

+    {

+      Range >>= 1;

+      if (((value >> i) & 1) == 1)

+        Low += Range;

+      if (Range < kTopValue)

+      {

+        Range <<= 8;

+        ShiftLow();

+      }

+    }

+  }

+

+  void EncodeBit(UInt32 size0, UInt32 numTotalBits, UInt32 symbol)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    if (symbol == 0)

+      Range = newBound;

+    else

+    {

+      Low += newBound;

+      Range -= newBound;

+    }

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  UInt64 GetProcessedSize() {  return Stream.GetProcessedSize() + _cacheSize + 4; }

+};

+

+class CDecoder

+{

+public:

+  CInBuffer Stream;

+  UInt32 Range;

+  UInt32 Code;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void Normalize()

+  {

+    while (Range < kTopValue)

+    {

+      Code = (Code << 8) | Stream.ReadByte();

+      Range <<= 8;

+    }

+  }

+  

+  void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Code = 0;

+    Range = 0xFFFFFFFF;

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

+      Code = (Code << 8) | Stream.ReadByte();

+  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  UInt32 GetThreshold(UInt32 total)

+  {

+    return (Code) / ( Range /= total);

+  }

+

+  void Decode(UInt32 start, UInt32 size)

+  {

+    Code -= start * Range;

+    Range *= size;

+    Normalize();

+  }

+

+  UInt32 DecodeDirectBits(int numTotalBits)

+  {

+    UInt32 range = Range;

+    UInt32 code = Code;        

+    UInt32 result = 0;

+    for (int i = numTotalBits; i != 0; i--)

+    {

+      range >>= 1;

+      /*

+      result <<= 1;

+      if (code >= range)

+      {

+        code -= range;

+        result |= 1;

+      }

+      */

+      UInt32 t = (code - range) >> 31;

+      code -= range & (t - 1);

+      result = (result << 1) | (1 - t);

+

+      if (range < kTopValue)

+      {

+        code = (code << 8) | Stream.ReadByte();

+        range <<= 8; 

+      }

+    }

+    Range = range;

+    Code = code;

+    return result;

+  }

+

+  UInt32 DecodeBit(UInt32 size0, UInt32 numTotalBits)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    UInt32 symbol;

+    if (Code < newBound)

+    {

+      symbol = 0;

+      Range = newBound;

+    }

+    else

+    {

+      symbol = 1;

+      Code -= newBound;

+      Range -= newBound;

+    }

+    Normalize();

+    return symbol;

+  }

+

+  UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }

+};

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp
new file mode 100644
index 000000000..8d273c8f9
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp
@@ -0,0 +1,80 @@
+// Compress/RangeCoder/RangeCoderBit.cpp

+

+#include "StdAfx.h"

+

+#include "RangeCoderBit.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+UInt32 CPriceTables::ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+static CPriceTables g_PriceTables;

+

+CPriceTables::CPriceTables() { Init(); }

+

+void CPriceTables::Init()

+{

+  const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);

+  for(int i = kNumBits - 1; i >= 0; i--)

+  {

+    UInt32 start = 1 << (kNumBits - i - 1);

+    UInt32 end = 1 << (kNumBits - i);

+    for (UInt32 j = start; j < end; j++)

+      ProbPrices[j] = (i << kNumBitPriceShiftBits) + 

+          (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));

+  }

+

+  /*

+  // simplest: bad solution

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = kBitPrice;

+  */

+  

+  /*

+  const double kDummyMultMid = (1.0 / kBitPrice) / 2;

+  const double kDummyMultMid = 0;

+  // float solution

+  double ln2 = log(double(2));

+  double lnAll = log(double(kBitModelTotal >> kNumMoveReducingBits));

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = UInt32((fabs(lnAll - log(double(i))) / ln2 + kDummyMultMid) * kBitPrice);

+  */

+  

+  /*

+  // experimental, slow, solution:

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+  {

+    const int kCyclesBits = 5;

+    const UInt32 kCycles = (1 << kCyclesBits);

+

+    UInt32 range = UInt32(-1);

+    UInt32 bitCount = 0;

+    for (UInt32 j = 0; j < kCycles; j++)

+    {

+      range >>= (kNumBitModelTotalBits - kNumMoveReducingBits);

+      range *= i;

+      while(range < (1 << 31))

+      {

+        range <<= 1;

+        bitCount++;

+      }

+    }

+    bitCount <<= kNumBitPriceShiftBits;

+    range -= (1 << 31);

+    for (int k = kNumBitPriceShiftBits - 1; k >= 0; k--)

+    {

+      range <<= 1;

+      if (range > (1 << 31))

+      {

+        bitCount += (1 << k);

+        range -= (1 << 31);

+      }

+    }

+    ProbPrices[i] = (bitCount 

+      // + (1 << (kCyclesBits - 1))

+      ) >> kCyclesBits;

+  }

+  */

+}

+

+}}

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h
new file mode 100644
index 000000000..64538e687
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h
@@ -0,0 +1,120 @@
+// Compress/RangeCoder/RangeCoderBit.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_H

+#define __COMPRESS_RANGECODER_BIT_H

+

+#include "RangeCoder.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumBitModelTotalBits  = 11;

+const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);

+

+const int kNumMoveReducingBits = 2;

+

+const int kNumBitPriceShiftBits = 6;

+const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;

+

+class CPriceTables

+{

+public:

+  static UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+  static void Init();

+  CPriceTables();

+};

+

+template <int numMoveBits>

+class CBitModel

+{

+public:

+  UInt32 Prob;

+  void UpdateModel(UInt32 symbol)

+  {

+    /*

+    Prob -= (Prob + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;

+    Prob += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);

+    */

+    if (symbol == 0)

+      Prob += (kBitModelTotal - Prob) >> numMoveBits;

+    else

+      Prob -= (Prob) >> numMoveBits;

+  }

+public:

+  void Init() { Prob = kBitModelTotal / 2; }

+};

+

+template <int numMoveBits>

+class CBitEncoder: public CBitModel<numMoveBits>

+{

+public:

+  void Encode(CEncoder *encoder, UInt32 symbol)

+  {

+    /*

+    encoder->EncodeBit(this->Prob, kNumBitModelTotalBits, symbol);

+    this->UpdateModel(symbol);

+    */

+    UInt32 newBound = (encoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (symbol == 0)

+    {

+      encoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+    }

+    else

+    {

+      encoder->Low += newBound;

+      encoder->Range -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+    }

+    if (encoder->Range < kTopValue)

+    {

+      encoder->Range <<= 8;

+      encoder->ShiftLow();

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    return CPriceTables::ProbPrices[

+      (((this->Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];

+  }

+  UInt32 GetPrice0() const { return CPriceTables::ProbPrices[this->Prob >> kNumMoveReducingBits]; }

+  UInt32 GetPrice1() const { return CPriceTables::ProbPrices[(kBitModelTotal - this->Prob) >> kNumMoveReducingBits]; }

+};

+

+

+template <int numMoveBits>

+class CBitDecoder: public CBitModel<numMoveBits>

+{

+public:

+  UInt32 Decode(CDecoder *decoder)

+  {

+    UInt32 newBound = (decoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (decoder->Code < newBound)

+    {

+      decoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 0;

+    }

+    else

+    {

+      decoder->Range -= newBound;

+      decoder->Code -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 1;

+    }

+  }

+};

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h
new file mode 100644
index 000000000..1fa023f3b
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h
@@ -0,0 +1,161 @@
+// Compress/RangeCoder/RangeCoderBitTree.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_TREE_H

+#define __COMPRESS_RANGECODER_BIT_TREE_H

+

+#include "RangeCoderBit.h"

+#include "RangeCoderOpt.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeEncoder

+{

+  CBitEncoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  void Encode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

+    for (int bitIndex = NumBitLevels; bitIndex != 0 ;)

+    {

+      bitIndex--;

+      UInt32 bit = (symbol >> bitIndex) & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+  };

+  void ReverseEncode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

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

+    {

+      UInt32 bit = symbol & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+      symbol >>= 1;

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    symbol |= (1 << NumBitLevels);

+    UInt32 price = 0;

+    while (symbol != 1)

+    {

+      price += Models[symbol >> 1].GetPrice(symbol & 1);

+      symbol >>= 1;

+    }

+    return price;

+  }

+  UInt32 ReverseGetPrice(UInt32 symbol) const

+  {

+    UInt32 price = 0;

+    UInt32 modelIndex = 1;

+    for (int i = NumBitLevels; i != 0; i--)

+    {

+      UInt32 bit = symbol & 1;

+      symbol >>= 1;

+      price += Models[modelIndex].GetPrice(bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+    return price;

+  }

+};

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeDecoder

+{

+  CBitDecoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  UInt32 Decode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    RC_INIT_VAR

+    for(int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)

+    {

+      // modelIndex = (modelIndex << 1) + Models[modelIndex].Decode(rangeDecoder);

+      RC_GETBIT(numMoveBits, Models[modelIndex].Prob, modelIndex)

+    }

+    RC_FLUSH_VAR

+    return modelIndex - (1 << NumBitLevels);

+  };

+  UInt32 ReverseDecode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    UInt32 symbol = 0;

+    RC_INIT_VAR

+    for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+    {

+      // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+      // modelIndex <<= 1;

+      // modelIndex += bit;

+      // symbol |= (bit << bitIndex);

+      RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+    }

+    RC_FLUSH_VAR

+    return symbol;

+  }

+};

+

+template <int numMoveBits>

+void ReverseBitTreeEncode(CBitEncoder<numMoveBits> *Models, 

+    CEncoder *rangeEncoder, int NumBitLevels, UInt32 symbol)

+{

+  UInt32 modelIndex = 1;

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

+  {

+    UInt32 bit = symbol & 1;

+    Models[modelIndex].Encode(rangeEncoder, bit);

+    modelIndex = (modelIndex << 1) | bit;

+    symbol >>= 1;

+  }

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeGetPrice(CBitEncoder<numMoveBits> *Models, 

+    UInt32 NumBitLevels, UInt32 symbol)

+{

+  UInt32 price = 0;

+  UInt32 modelIndex = 1;

+  for (int i = NumBitLevels; i != 0; i--)

+  {

+    UInt32 bit = symbol & 1;

+    symbol >>= 1;

+    price += Models[modelIndex].GetPrice(bit);

+    modelIndex = (modelIndex << 1) | bit;

+  }

+  return price;

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeDecode(CBitDecoder<numMoveBits> *Models, 

+    CDecoder *rangeDecoder, int NumBitLevels)

+{

+  UInt32 modelIndex = 1;

+  UInt32 symbol = 0;

+  RC_INIT_VAR

+  for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+  {

+    // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+    // modelIndex <<= 1;

+    // modelIndex += bit;

+    // symbol |= (bit << bitIndex);

+    RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+  }

+  RC_FLUSH_VAR

+  return symbol;

+}

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h
new file mode 100644
index 000000000..829fc83d7
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h
@@ -0,0 +1,31 @@
+// Compress/RangeCoder/RangeCoderOpt.h

+

+#ifndef __COMPRESS_RANGECODER_OPT_H

+#define __COMPRESS_RANGECODER_OPT_H

+

+#define RC_INIT_VAR \

+  UInt32 range = rangeDecoder->Range; \

+  UInt32 code = rangeDecoder->Code;        

+

+#define RC_FLUSH_VAR \

+  rangeDecoder->Range = range; \

+  rangeDecoder->Code = code;

+

+#define RC_NORMALIZE \

+  if (range < NCompress::NRangeCoder::kTopValue) \

+    { code = (code << 8) | rangeDecoder->Stream.ReadByte(); range <<= 8; }

+

+#define RC_GETBIT2(numMoveBits, prob, mi, A0, A1) \

+  { UInt32 bound = (range >> NCompress::NRangeCoder::kNumBitModelTotalBits) * prob; \

+  if (code < bound) \

+  { A0; range = bound; \

+    prob += (NCompress::NRangeCoder::kBitModelTotal - prob) >> numMoveBits; \

+    mi <<= 1; } \

+  else \

+  { A1; range -= bound; code -= bound; prob -= (prob) >> numMoveBits; \

+    mi = (mi + mi) + 1; }} \

+  RC_NORMALIZE

+

+#define RC_GETBIT(numMoveBits, prob, mi) RC_GETBIT2(numMoveBits, prob, mi, ; , ;)

+

+#endif