KKB::SimpleCompressor Class Reference

#include <SimpleCompressor.h>

Public Member Functions
	SimpleCompressor (kkuint32 estimatedMaxBuffSize)
	SimpleCompressor (uchar *compressdBuff)
	~SimpleCompressor ()
void	Add16BitInt (kkuint32 i)
void	AddByte (uchar b)
uchar *	CreateCompressedBuffer (kkuint32 &compressedBuffserSize)

Static Public Member Functions
static uchar *	Decompress (const uchar *compressedBuff, kkuint32 compressedBuffLen, kkuint32 &unCompressedSize)

Detailed Description

Definition at line 10 of file SimpleCompressor.h.

Constructor & Destructor Documentation

SimpleCompressor::SimpleCompressor

(

kkuint32

estimatedMaxBuffSize

)

Definition at line 24 of file SimpleCompressor.cpp.

Referenced by KKB::Raster::SimpleCompression().

{
  buffBytes = new uchar[estimatedMaxBuffSize];
  buffLens  = new uchar[estimatedMaxBuffSize];

  buffSize = estimatedMaxBuffSize;
  buffSpaceUsed = 0;
  lastBuffByteUsed = 0;
  growthRate = estimatedMaxBuffSize;
}

KKB::SimpleCompressor::SimpleCompressor

(

uchar *

compressdBuff

)

SimpleCompressor::~SimpleCompressor

(

)

Definition at line 37 of file SimpleCompressor.cpp.

{
  delete[]  buffBytes;
  delete[]  buffLens;
}

Member Function Documentation

void SimpleCompressor::Add16BitInt

(

kkuint32

i

)

Definition at line 45 of file SimpleCompressor.cpp.

References AddByte().

Referenced by KKB::Raster::SimpleCompression().

{
  AddByte ((uchar)(i / 256));
  AddByte ((uchar)(i % 256));
}

void SimpleCompressor::AddByte

(

uchar

b

)

Definition at line 53 of file SimpleCompressor.cpp.

Referenced by Add16BitInt(), and KKB::Raster::SimpleCompression().

{
  if  (buffSpaceUsed >= buffSize)
  {
    kkuint32  newBuffSize = buffSize + growthRate;
    uchar*  newBuffBytes = new uchar[newBuffSize];
    uchar*  newBuffLens = new uchar[newBuffSize];

    memcpy (newBuffBytes, buffBytes, buffSize);
    memcpy (newBuffLens,  buffLens, buffSize);
    delete  buffBytes;
    delete  buffLens;
    buffBytes = newBuffBytes;
    buffLens  = newBuffLens;
    newBuffBytes = NULL;
    newBuffLens  = NULL;
    buffSize     = newBuffSize;
  }

  if  (buffSpaceUsed == 0)
  {
    buffBytes[0]     = b;
    buffLens [0]     = 1;
    lastBuffByteUsed = 0;
    buffSpaceUsed    = 1;

    return;
  }

  if  (b == buffBytes[lastBuffByteUsed])
  {
    if  (buffLens[lastBuffByteUsed] > 126)
    {
      buffBytes[buffSpaceUsed] = b;
      buffLens [buffSpaceUsed] = 1;
      lastBuffByteUsed = buffSpaceUsed;
      buffSpaceUsed++;
    }
    else
    {
      buffLens[lastBuffByteUsed]++;
    }
  }
  else
  {
    buffBytes[buffSpaceUsed] = b;
    buffLens [buffSpaceUsed] = 1;
    lastBuffByteUsed = buffSpaceUsed;
    buffSpaceUsed++;
  }
} /* AddByte */

uchar * SimpleCompressor::CreateCompressedBuffer

(

kkuint32 &

compressedBuffserSize

)

Definition at line 172 of file SimpleCompressor.cpp.

Referenced by KKB::Raster::SimpleCompression().

{
  kkuint32  compressedBytesNeeded = CalcCompressedBytesNeeded ();

  if  (compressedBytesNeeded > (256 * 256))
  {
    ofstream  f ("c:\\Temp\\SimpleCompressor.txt", ios_base::app);
    f << std::endl
      << osGetLocalDateTime () << "\t"
      << "SimpleCompressor::CreateCompressedBuffer     ***ERROR***     compressedBytesNeeded[" << compressedBytesNeeded << "] to large." << std::endl
      << std::endl;
    f.flush ();
    f.close ();
    compressedBuffserSize = compressedBytesNeeded;
    return NULL;
  }


  uchar*  compressedBuff = new uchar[compressedBytesNeeded];
  kkuint32  compressedBuffUsed = 0;

  AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, compressedBytesNeeded / 256);
  AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, compressedBytesNeeded % 256);

  kkuint32  idx = 0;

  while  (idx < buffSpaceUsed)
  {
    while  ((idx < buffSpaceUsed)  &&  (buffLens[idx] > 1))
    {
      AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, 128 + buffLens[idx]);
      AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, buffBytes[idx]);
      idx++;
    }

    while  ((idx < buffSpaceUsed)  &&  (buffLens[idx] <= 1))
    {
      // We have some raw bytes to add.
      // Lets look forward to see how many

      kkuint32  endIdx = idx;
      kkuint32  rawBytesInARow = 0;
      while  ((endIdx < buffSpaceUsed)  &&  (buffLens[endIdx] <= 1)  &&  (rawBytesInARow < 127))
      {
        endIdx++;
        rawBytesInARow++;
      }

      endIdx--;

      
      AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, 0 + rawBytesInARow);
      for  (kkuint32 x = 0;   x < rawBytesInARow;  x++)
      {
        AddByteToCmpressedBuffer (compressedBuff, compressedBuffUsed, buffBytes[idx]);
        idx++;
      }
    }
  }

  if  (compressedBuffUsed != compressedBytesNeeded)
  {
    // This is not a good thing; something has damaged the compressed string.
    ofstream  f ("c:\\Temp\\SimpleCompressor.txt", ios_base::app);
    f << std::endl
      << osGetLocalDateTime () << "\t" << "SimpleCompressor::CreateCompressedBuffer    ***ERROR***"
      << std::endl
      << "               "     << "\t" << "Something has gone terribly wrong with the simpleCompression algorithm." << std::endl
      << std::endl;
    f.flush ();
    f.close ();
  }


  compressedBuffserSize = compressedBuffUsed;

  return  compressedBuff;
}   /* CreateCompressedBuffer*/

uchar * SimpleCompressor::Decompress ( const uchar *  compressedBuff, kkuint32  compressedBuffLen, kkuint32 &  unCompressedSize  )

static

Definition at line 255 of file SimpleCompressor.cpp.

Referenced by KKB::Raster::FromSimpleCompression().

{
  if  ((compressedBuff == NULL)  ||  ((compressedBuffLen < 2)))
    return  NULL;

  // First two bytes specifies the total number of compressed bytes including the first two bytes.
  kkuint32  compressedBuffSize = compressedBuff[0] * 256 + compressedBuff[1];

  if  (compressedBuffSize > compressedBuffLen)
  {
    ofstream  f ("c:\\Temp\\SimpleCompressor.txt", ios_base::app);
    f << std::endl
      << osGetLocalDateTime ()  << "\t"
      << "compressedBuffSize[" << compressedBuffSize << "] > compressedBuffLen[" << compressedBuffLen << "]" << "\t" 
      << std::endl;
    f.flush ();
    f.close ();

    compressedBuffSize = compressedBuffLen;
  }

  kkuint32  nextByte = 2;

  // Calculate the number of uncompressed bytes needed.  Which is done by decompressing the data.
  unCompressedSize = 0;
  while  (nextByte < (compressedBuffSize - 1))  // There has to be at least 2 bytes in each group
  {
    uchar  controlByte = compressedBuff[nextByte];
    nextByte += 1;

    if  (controlByte < 128)
    {
      // Raw data that consists of 'controlByte' bytes.
      unCompressedSize = unCompressedSize + controlByte;
      nextByte = nextByte + controlByte;
    }
    else
    {
      // Run Length data;  next byte represents the byte that is to be repeated 'controByte' times.
      unCompressedSize = unCompressedSize + (controlByte % 128);
      nextByte = nextByte + 1;
    }
  }

  if  (nextByte > compressedBuffSize)
  {
    // This is not a good thing; something has damaged the compressed string.
    ofstream  f ("c:\\Temp\\SimpleCompressor.txt", ios_base::app);
    f << std::endl
      << osGetLocalDateTime ()  << "\t"
      << "nextByte[" <<  nextByte << "] > compressedBuffSize[" << compressedBuffSize << "]"
      << std::endl;
    f.flush ();
    f.close ();
  }

  uchar*  unCompressedBuff = new uchar[unCompressedSize];
  memset (unCompressedBuff, 0, unCompressedSize);

  nextByte = 2;

  kkuint32  unCompressedBuffIDX = 0;

  while  (nextByte < (compressedBuffSize - 1))
  {
    uchar  controlByte = compressedBuff[nextByte];
    if  (controlByte < 128)
    {
      // We have raw data that consists of 'controlByte' bytes.
      nextByte++;  // Step past control byte.

      for  (kkint32 x = 0;  (x < controlByte)   &&  (nextByte < compressedBuffSize);  x++)
      {
        unCompressedBuff[unCompressedBuffIDX] = compressedBuff[nextByte];
        unCompressedBuffIDX++;
        nextByte++;
      }
    }
    else
    {
      // Since the control byte is 128 or greater;  then we are dealing with a repeating value.
      controlByte = controlByte % 128;  // Get the lower 7 bits 
      nextByte++;  // Step past control byte so now we are pointing at byte that is to be repeated.
      for  (kkint32 x = 0;  x < controlByte;  x++)
      {
        unCompressedBuff[unCompressedBuffIDX] = compressedBuff[nextByte];
        unCompressedBuffIDX++;
      }
      nextByte++;  // Move us to next control Byte.
    }
  }

  if  (unCompressedBuffIDX != unCompressedSize)
  {
    cerr << std::endl
         << std::endl
         << "SimpleCompressor::Decompress     ***ERROR***" << std::endl
         << std::endl
         << "                       Did not decompress correctly." << std::endl
         << std::endl;
  }
  return  unCompressedBuff;
}  /* Decompress */

---

The documentation for this class was generated from the following files:

• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/SimpleCompressor.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/SimpleCompressor.cpp