MCZipper.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MCZipper.hpp"

#include "MCBinaryData.hpp"
#include "MCDefs.hpp"
#include "MCLog.hpp"
#include "MCThreadLocalData.hpp"
#include "MCTimer.hpp"

#include <bzlib.h>
#include <lz4.h>
#include <lzoconf.h>
#include <minilzo.h>
#include <quicklz.h>
#include <Shrinker.h>
#include <snappy.h>
#include <zlib.h>

// This include needed to avoid redefinition warning/error with __STDC_LIMIT_MACROS on MinGW caused by minilzo.h
#if defined(__MINGW32__) || defined(__MINGW64__)
#include <boost/config.hpp>
#endif

namespace
{
// Compression buffer
MCThreadLocalData<qlz_state_compress> StateCompress(true);
MCThreadLocalData<qlz_state_decompress> StateDecompress(true);
MCThreadLocalData<MCBinaryData> CompressionBuffer(true);

void CheckStaticZipperVariables()
{
  if (unlikely(!CompressionBuffer.get()))
  {
    CompressionBuffer.reset(new MCBinaryData(10000));
    StateCompress.reset(new qlz_state_compress);
    // We can get "Conditional jump or move depends on uninitialised value(s)" error
    // in valgrind if this structure is not cleared.
    memset(StateCompress.get(), 0, sizeof(qlz_state_compress));
    StateDecompress.reset(new qlz_state_decompress);
    // We can get "Conditional jump or move depends on uninitialised value(s)" error
    // in valgrind if this structure is not cleared.
    memset(StateDecompress.get(), 0, sizeof(qlz_state_decompress));
  }
}
}

namespace MC
{
const StringList CompressionTypeStrs = {"Invalid", "Lz4", "Zlib", "QuickLZ", "MiniLzo", "Shrinker",
                                        "Snappy", "Bzip2"};
const StringList CompressionLevelTypeStrs = {"Fast", "Medium", "Best"};
}

void MCZipper::CompressQuickLz(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  CheckStaticZipperVariables();
  // Test with quicklz
  // The benchmark used compressed audio data on AIBO.
  // Level 1: 181229 -> 138162 (164753 bytes / 10 msec)
  // Level 2: 181229 -> 109329 (120819 bytes / 10 msec)
  // Level 3: 181229 -> 109838 (226536 bytes / 10 msec) <-- This level is used
  int CompressedSize = 0;
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::QuickLzCompression];

  if (CompressionBuffer->GetSize() < input_buffer.GetSize()+400+(int)IdStr.size())
  {
    CompressionBuffer->Allocate(input_buffer.GetSize()+400+IdStr.size());
  }
  CompressedSize = qlz_compress((char*)input_buffer.GetData(), (char*)CompressionBuffer->GetData(),
                                input_buffer.GetSize(), &*StateCompress);
  int FinalSize = CompressedSize+(int)IdStr.size()+4;

  if (output_buffer.GetSize() != FinalSize)
  {
    output_buffer.Allocate(FinalSize);
  }
  output_buffer.SetPosition(0);
  output_buffer.AddInt32(FinalSize);
  memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
  memcpy((char*)&output_buffer.GetData()[IdStr.size()+4], (char*)CompressionBuffer->GetData(),
         CompressedSize);
}


void MCZipper::DecompressQuickLz(const MCBinaryData& input_buffer, MCBinaryData& output_buffer,
                                 bool without_header)
{
  if (!without_header && DetectCompressionMethod(input_buffer) != MC::QuickLzCompression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::QuickLzCompression];
  char* DataStart = !without_header ? (char*)&input_buffer.GetData()[IdStr.size()+4] :
                        (char*)input_buffer.GetData();
  int DecompressedSize = qlz_size_decompressed(DataStart);

  if (!without_header)
  {
    MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
    int OldPosition = input_buffer.GetPosition();
    int PacketSize = 0;

    Packet.SetPosition(0);
    PacketSize = Packet.GetInt32();
    Packet.SetPosition(OldPosition);
    if (PacketSize != input_buffer.GetSize())
      return;
  }
  if (output_buffer.GetSize() != DecompressedSize)
  {
    output_buffer.Allocate(DecompressedSize);
  }
  qlz_decompress(DataStart, (char*)output_buffer.GetData(), &*StateDecompress);
}


void MCZipper::CompressLz4(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::Lz4Compression];
  int BufferSize = LZ4_compressBound(input_buffer.GetSize());

  if (CompressionBuffer->GetSize() < BufferSize)
  {
    CompressionBuffer->Allocate(BufferSize);
  }
  int OriginalSize = input_buffer.GetSize();
  int CompressedSize = LZ4_compress((char*)input_buffer.GetData(), (char*)CompressionBuffer->GetData(),
                                    input_buffer.GetSize());
  int FinalSize = CompressedSize+(int)IdStr.size()+12;

  if (output_buffer.GetSize() != FinalSize)
  {
    output_buffer.Allocate(FinalSize);
  }
  output_buffer.SetPosition(0);
  output_buffer.AddInt32(FinalSize);
  memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
  output_buffer.IncrementPosition(IdStr.size());
  output_buffer.AddInt32(OriginalSize);
  output_buffer.AddInt32(CompressedSize);
  memcpy((char*)&output_buffer.GetData()[IdStr.size()+12], (char*)CompressionBuffer->GetData(),
         CompressedSize);
}


void MCZipper::DecompressLz4(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::Lz4Compression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::Lz4Compression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;
  int OriginalSize = 0;
  int CompressedSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.IncrementPosition(IdStr.size());
  OriginalSize = Packet.GetInt32();
  CompressedSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize() || OriginalSize <= 0 ||
      CompressedSize+12+(int)IdStr.size() != input_buffer.GetSize())
  {
    return;
  }
  if (CompressionBuffer->GetSize() < OriginalSize)
  {
    CompressionBuffer->Allocate(OriginalSize);
  }
  int Result = LZ4_decompress_safe((char*)&input_buffer.GetData()[IdStr.size()+12],
                                   (char*)CompressionBuffer->GetData(),
                                   input_buffer.GetSize()-IdStr.size()-12, CompressionBuffer->GetSize());

  if (Result != OriginalSize)
    return;
  if (output_buffer.GetSize() != Result)
  {
    output_buffer.Allocate(Result);
  }
  memcpy(output_buffer.GetData(), CompressionBuffer->GetData(), Result);
}


void MCZipper::CompressMiniLzo(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::MiniLzoCompression];
  int BufferSize = (int)input_buffer.GetSize()*11 / 10+100;

  output_buffer.Allocate((int)LZO1X_1_MEM_COMPRESS);
  if (CompressionBuffer->GetSize() < BufferSize)
  {
    CompressionBuffer->Allocate(BufferSize);
  }
  lzo_init();

  lzo_uint OutputBufferSize = (lzo_uint)output_buffer.GetSize();
  int Result = lzo1x_1_compress((lzo_bytep)input_buffer.GetData(), (lzo_uint)input_buffer.GetSize(),
                                (lzo_bytep)CompressionBuffer->GetData(), (lzo_uintp)&OutputBufferSize,
                                (lzo_voidp)output_buffer.GetData());

  if (Result == LZO_E_OK)
  {
    int FinalSize = (int)OutputBufferSize+(int)IdStr.size()+8;
    int OriginalSize = input_buffer.GetSize();

    if (output_buffer.GetSize() != FinalSize)
    {
      output_buffer.Allocate(FinalSize);
    }
    output_buffer.SetPosition(0);
    output_buffer.AddInt32(FinalSize);
    memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
    output_buffer.IncrementPosition(IdStr.size());
    output_buffer.AddInt32(OriginalSize);
    memcpy((char*)&output_buffer.GetData()[IdStr.size()+8], (char*)CompressionBuffer->GetData(),
           (int)OutputBufferSize);
  }
}


void MCZipper::DecompressMiniLzo(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::MiniLzoCompression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::MiniLzoCompression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;
  int OriginalSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.IncrementPosition(IdStr.size());
  OriginalSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize() || OriginalSize <= 0)
    return;
  lzo_init();
  if (CompressionBuffer->GetSize() < OriginalSize)
  {
    CompressionBuffer->Allocate(OriginalSize);
  }
  lzo_uint FinalSize = CompressionBuffer->GetSize();
  int Result = lzo1x_decompress_safe((lzo_bytep)&input_buffer.GetData()[IdStr.size()+8],
                                     (lzo_uint)(input_buffer.GetSize()-IdStr.size()-8),
                                     (lzo_bytep)CompressionBuffer->GetData(), (lzo_uintp)&FinalSize,
                                     (lzo_voidp)nullptr);

  if (Result != LZO_E_OK)
    return;
  if (output_buffer.GetSize() != (int)FinalSize)
  {
    output_buffer.Allocate((int)FinalSize);
  }
  memcpy(output_buffer.GetData(), CompressionBuffer->GetData(), (int)FinalSize);
}


void MCZipper::CompressShrinker(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::ShrinkerCompression];

  if (CompressionBuffer->GetSize() < input_buffer.GetSize()+200)
  {
    CompressionBuffer->Allocate(input_buffer.GetSize()+200);
  }
  int Result = shrinker_compress((char*)input_buffer.GetData(), (char*)CompressionBuffer->GetData(),
                                 input_buffer.GetSize());

  if (Result > 0)
  {
    int FinalSize = Result+(int)IdStr.size()+8;
    int OriginalSize = input_buffer.GetSize();

    if (output_buffer.GetSize() != FinalSize)
    {
      output_buffer.Allocate(FinalSize);
    }
    output_buffer.SetPosition(0);
    output_buffer.AddInt32(FinalSize);
    memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
    output_buffer.IncrementPosition(IdStr.size());
    output_buffer.AddInt32(OriginalSize);
    memcpy((char*)&output_buffer.GetData()[IdStr.size()+8], (char*)CompressionBuffer->GetData(), Result);
  }
}


void MCZipper::DecompressShrinker(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::ShrinkerCompression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::ShrinkerCompression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;
  int OriginalSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.IncrementPosition(IdStr.size());
  OriginalSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize() || input_buffer.GetSize() < 36+(int)IdStr.size()+8 ||
      OriginalSize <= 0)
  {
    return;
  }
  if (output_buffer.GetSize() < OriginalSize)
  {
    output_buffer.Allocate(OriginalSize);
  }
  shrinker_decompress(&input_buffer.GetData()[IdStr.size()+8], output_buffer.GetData());
}


void MCZipper::CompressSnappy(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::SnappyCompression];
  size_t BufferSize = (int)snappy::MaxCompressedLength((size_t)input_buffer.GetSize())+IdStr.size();

  if (CompressionBuffer->GetSize() < (int)BufferSize)
  {
    CompressionBuffer->Allocate((int)BufferSize);
  } else {
    BufferSize = (size_t)CompressionBuffer->GetSize();
  }
  snappy::RawCompress((char*)input_buffer.GetData(), (size_t)input_buffer.GetSize(),
                      (char*)CompressionBuffer->GetData(), &BufferSize);
  int FinalSize = (int)BufferSize+(int)IdStr.size()+8;

  if (output_buffer.GetSize() != FinalSize)
  {
    output_buffer.Allocate(FinalSize);
  }
  output_buffer.SetPosition(0);
  output_buffer.AddInt32(FinalSize);
  memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
  memcpy((char*)&output_buffer.GetData()[IdStr.size()+4], (char*)CompressionBuffer->GetData(),
         (int)BufferSize);
}


void MCZipper::DecompressSnappy(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::SnappyCompression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::SnappyCompression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize())
    return;

  size_t DecompressedSize = 0;

  if (snappy::GetUncompressedLength((char*)&input_buffer.GetData()[IdStr.size()+4],
                                    (size_t)(input_buffer.GetSize()-IdStr.size()-4),
                                    &DecompressedSize))
  {
    if (output_buffer.GetSize() != (int)DecompressedSize)
    {
      output_buffer.Allocate((int)DecompressedSize);
    }
    snappy::RawUncompress((char*)&input_buffer.GetData()[IdStr.size()+4],
                          (size_t)(input_buffer.GetSize()-IdStr.size()-4),
                          (char*)output_buffer.GetData());
  }
}


void MCZipper::CompressZlib(const MCBinaryData& input_buffer, MCBinaryData& output_buffer,
                            MC::CompressionLevelsType compression_level)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::ZlibCompression];
  uLong BufferSize = compressBound((uLong)input_buffer.GetSize())+IdStr.size()+8;

  if (CompressionBuffer->GetSize() < (int)BufferSize)
  {
    CompressionBuffer->Allocate((int)BufferSize);
  }
  uLongf OutputBufferSize = (uLongf)CompressionBuffer->GetSize();
  int CompressionLevel = compression_level == MC::BestCompression ? Z_BEST_COMPRESSION :
                             (compression_level == MC::MediumCompression ? Z_DEFAULT_COMPRESSION :
                                 Z_BEST_SPEED);
  compress2((Bytef*)CompressionBuffer->GetData(), &OutputBufferSize, (Bytef*)input_buffer.GetData(),
            (uLong)input_buffer.GetSize(), CompressionLevel);
  int FinalSize = (int)OutputBufferSize+(int)IdStr.size()+8;
  int OriginalSize = input_buffer.GetSize();

  if (output_buffer.GetSize() != FinalSize)
  {
    output_buffer.Allocate((int)FinalSize);
  }
  output_buffer.SetPosition(0);
  output_buffer.AddInt32(FinalSize);
  memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
  output_buffer.IncrementPosition(IdStr.size());
  output_buffer.AddInt32(OriginalSize);
  memcpy((char*)&output_buffer.GetData()[IdStr.size()+8], (char*)CompressionBuffer->GetData(),
         (int)OutputBufferSize);
}


void MCZipper::DecompressZlib(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::ZlibCompression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::ZlibCompression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;
  int OriginalSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.IncrementPosition(IdStr.size());
  OriginalSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize() || OriginalSize <= 0)
    return;
  if (CompressionBuffer->GetSize() < OriginalSize)
  {
    CompressionBuffer->Allocate(OriginalSize);
  }
  uLongf FinalSize = (uLongf)CompressionBuffer->GetSize();
  int Result = uncompress((Bytef*)CompressionBuffer->GetData(), &FinalSize,
                          (Bytef*)&input_buffer.GetData()[IdStr.size()+8],
                          (uLong)(input_buffer.GetSize()-IdStr.size()-8));

  if (Result == Z_OK)
  {
    output_buffer.Allocate((int)FinalSize);
    memcpy(output_buffer.GetData(), CompressionBuffer->GetData(), (int)FinalSize);
  }
}


void MCZipper::CompressBzip2(const MCBinaryData& input_buffer, MCBinaryData& output_buffer,
                             MC::CompressionLevelsType compression_level)
{
  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::Bzip2Compression];
  unsigned int BufferSize = input_buffer.GetSize()*105 / 100+700;

  if (CompressionBuffer->GetSize() < (int)BufferSize)
  {
    CompressionBuffer->Allocate((int)BufferSize);
  }
  int CompressionLevel = compression_level == MC::BestCompression ? 9 :
                             (compression_level == MC::MediumCompression ? 5 : 1);

  BZ2_bzBuffToBuffCompress((char*)CompressionBuffer->GetData(), &BufferSize,
                           (char*)input_buffer.GetData(), input_buffer.GetSize(),
                          CompressionLevel, 0, 0);
  int FinalSize = (int)BufferSize+(int)IdStr.size()+8;
  int OriginalSize = input_buffer.GetSize();

  if (output_buffer.GetSize() != FinalSize)
  {
    output_buffer.Allocate(FinalSize);
  }
  output_buffer.SetPosition(0);
  output_buffer.AddInt32(FinalSize);
  memcpy((char*)&output_buffer.GetData()[4], IdStr.c_str(), IdStr.size());
  output_buffer.IncrementPosition(IdStr.size());
  output_buffer.AddInt32(OriginalSize);
  memcpy((char*)&output_buffer.GetData()[IdStr.size()+8], (char*)CompressionBuffer->GetData(),
         BufferSize);
}


void MCZipper::DecompressBzip2(const MCBinaryData& input_buffer, MCBinaryData& output_buffer)
{
  if (DetectCompressionMethod(input_buffer) != MC::Bzip2Compression)
    return;

  CheckStaticZipperVariables();
  std::string IdStr = MC::CompressionTypeStrs[(int)MC::Bzip2Compression];
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();
  int PacketSize = 0;
  int OriginalSize = 0;

  Packet.SetPosition(0);
  PacketSize = Packet.GetInt32();
  Packet.IncrementPosition(IdStr.size());
  OriginalSize = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (PacketSize != input_buffer.GetSize() || OriginalSize <= 0)
    return;
  if (CompressionBuffer->GetSize() < OriginalSize)
  {
    CompressionBuffer->Allocate(OriginalSize);
  }
  unsigned int DecompressedSize = CompressionBuffer->GetSize();
  int Result = BZ2_bzBuffToBuffDecompress((char*)CompressionBuffer->GetData(), &DecompressedSize,
                                          (char*)&input_buffer.GetData()[IdStr.size()+8],
                                          input_buffer.GetSize()-IdStr.size()-8, 0, 0);

  if (Result == BZ_OK)
  {
    output_buffer.Allocate((int)DecompressedSize);
    memcpy(output_buffer.GetData(), CompressionBuffer->GetData(), (int)DecompressedSize);
  }
}


MC::CompressionDescriptor MCZipper::FindBestCompression(const MCBinaryData& input_buffer,
                                                        MCBinaryData& output_buffer, bool test_mode)
{
  MC::BinaryDataSPtr TempBuffer(new MCBinaryData);
  MC::CompressionDescriptor BestCompression;
  MCTimer Timer;

  if (test_mode)
    MC_LOG("Original data size: %d", input_buffer.GetSize());
  BestCompression.second = MC::MediumCompression;
  for (int i = (int)MC::Lz4Compression; i <= (int)MC::Bzip2Compression; ++i)
  {
    for (int i1 = (int)MC::FastCompression; i1 <= (int)MC::BestCompression; ++i1)
    {
      if ((i1 == (int)MC::FastCompression || i1 == (int)MC::BestCompression) &&
          i != (int)MC::Bzip2Compression && i != (int)MC::ZlibCompression)
      {
        continue;
      }
      Timer.Start();
      if (i == (int)MC::Lz4Compression)
        CompressLz4(input_buffer, *TempBuffer);
      if (i == (int)MC::ZlibCompression)
        CompressZlib(input_buffer, *TempBuffer, (MC::CompressionLevelsType)i1);
      if (i == (int)MC::QuickLzCompression)
        CompressQuickLz(input_buffer, *TempBuffer);
      if (i == (int)MC::MiniLzoCompression)
        CompressMiniLzo(input_buffer, *TempBuffer);
      if (i == (int)MC::ShrinkerCompression)
        CompressShrinker(input_buffer, *TempBuffer);
      if (i == (int)MC::SnappyCompression)
        CompressSnappy(input_buffer, *TempBuffer);
      if (i == (int)MC::Bzip2Compression)
        CompressBzip2(input_buffer, *TempBuffer, (MC::CompressionLevelsType)i1);

      if (test_mode)
      {
        MC::BinaryDataSPtr TempBuffer2(new MCBinaryData);

        MC_LOG("Compression size and speed (%s/%s): %d bytes, %d bytes / msec",
               MC::CompressionTypeStrs[i].c_str(), MC::CompressionLevelTypeStrs[i1].c_str(),
               TempBuffer->GetSize(),
               (int)((int64_t)input_buffer.GetSize()*1000 / Timer.GetElapsedTimeInUSecs()));
        Timer.Start();
        if (i == (int)MC::Lz4Compression)
          DecompressLz4(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::ZlibCompression)
          DecompressZlib(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::QuickLzCompression)
          DecompressQuickLz(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::MiniLzoCompression)
          DecompressMiniLzo(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::ShrinkerCompression)
          DecompressShrinker(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::SnappyCompression)
          DecompressSnappy(*TempBuffer, *TempBuffer2);
        if (i == (int)MC::Bzip2Compression)
          DecompressBzip2(*TempBuffer, *TempBuffer2);
        int64_t ElapsedTime = Timer.GetElapsedTimeInUSecs();

        ElapsedTime = (ElapsedTime > 0 ? ElapsedTime : 1);
        MC_LOG("Decompression speed (%s/%s): %d bytes / msec",
               MC::CompressionTypeStrs[i].c_str(), MC::CompressionLevelTypeStrs[i1].c_str(),
               (int)((int64_t)input_buffer.GetSize()*1000 / ElapsedTime));
      }
      if (i == (int)MC::Lz4Compression || TempBuffer->GetSize() < output_buffer.GetSize())
      {
        output_buffer = std::move(*TempBuffer);
        BestCompression.first = (MC::CompressionsType)i;
        BestCompression.second = (MC::CompressionLevelsType)i1;
      }
    }
  }
  return BestCompression;
}


MC::CompressionsType MCZipper::DetectCompressionMethod(const MCBinaryData& input_buffer,
                                                       MC::CompressionsType compression)
{
  if (input_buffer.GetSize() < 4)
    return MC::InvalidCompression;

  int Size = 0;
  MCBinaryData& Packet = const_cast<MCBinaryData&>(input_buffer);
  int OldPosition = Packet.GetPosition();

  Packet.SetPosition(0);
  Size = Packet.GetInt32();
  Packet.SetPosition(OldPosition);
  if (Size < 0 || Size > input_buffer.GetSize())
    return MC::InvalidCompression;
  for (int i = (int)MC::Lz4Compression; i <= (int)MC::Bzip2Compression; ++i)
  {
    // Skip other methods if a desired one is specified
    if (compression != MC::InvalidCompression && compression != (MC::CompressionsType)i)
      continue;

    std::string IdStr = MC::CompressionTypeStrs[(MC::CompressionsType)i];

    if (input_buffer.GetSize() < (int)IdStr.size()+4)
      continue;
    bool Found = true;

    for (unsigned int i1 = 0; i1 < IdStr.size(); ++i1)
    {
      if (IdStr.c_str()[i1] != input_buffer.GetData()[i1+4])
      {
        Found = false;
        break;
      }
    }
    if (Found)
      return (MC::CompressionsType)i;
  }
  return MC::InvalidCompression;
}


void MCZipper::ReleaseCache()
{
  CheckStaticZipperVariables();
  CompressionBuffer->Allocate(10000);
}