ACE/ace/Compression/rle/RLECompressor.cpp

   1 #include "RLECompressor.h"
   2 #include "ace/OS_NS_string.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 ACE_RLECompressor::ACE_RLECompressor()
   7     : ACE_Compressor(ACE_COMPRESSORID_RLE)
   8 {
   9 }
  10
  11 // Compress using Run Length Encoding (RLE)
  12 ACE_UINT64
  13 ACE_RLECompressor::compress(const void *in_ptr,
  14                             ACE_UINT64 in_len,
  15                             void *out_ptr,
  16                             ACE_UINT64 max_out_len)
  17 {
  18     const ACE_Byte *in_p    = static_cast<const ACE_Byte *>(in_ptr);
  19     ACE_Byte *out_p         = static_cast<ACE_Byte *>(out_ptr);
  20
  21     ACE_UINT64 src_len      = in_len;  // Save for stats
  22     ACE_UINT64 out_index    = 0;
  23     ACE_UINT64 out_base     = 0;
  24     size_t     run_count    = 0;
  25     bool       run_code     = false;
  26
  27     if (in_p && out_p && in_len) {
  28         while (in_len-- > 0) {
  29             ACE_Byte cur_byte = *in_p++;
  30
  31             switch (out_index ? run_count : 128U) {  // BootStrap to 128
  32
  33             case 128:
  34
  35                 if ((out_base = out_index++) >= max_out_len) {
  36                     return ACE_UINT64(-1);      // Output Exhausted
  37                 }
  38                 run_code  = false;
  39                 run_count = 0; // Switch off compressing
  40
  41                 // Fall Through
  42
  43             default:
  44
  45                 // Fix problem where input exhaused but maybe compressing
  46                 if (in_len ? cur_byte == *in_p : run_code) {
  47                     if (run_code) {             // In Compression?
  48                         out_p[out_base] = ACE_Byte(run_count++ | 0x80);
  49                         continue;               // Stay in Compression
  50                     } else if (run_count) {     // Xfering to Compression
  51                         if ((out_base = out_index++) >= max_out_len) {
  52                             return ACE_UINT64(-1); // Output Exhausted
  53                         }
  54                         run_count = 0;
  55                     }
  56                     run_code  = true;           // We Are Now Compressing
  57
  58                 } else if (run_code) {          // Are we in Compression?
  59                     // Finalise the Compression Run Length
  60                     out_p[out_base] = ACE_Byte(run_count | 0x80);
  61                     // Reset for Uncmpressed
  62                     if (in_len && (out_base = out_index++) >= max_out_len) {
  63                         return ACE_UINT64(-1);  // Output Exhausted
  64                     }
  65                     run_code    = false;
  66                     run_count   = 0;
  67                     continue;   // Now restart Uncompressed
  68                 }
  69
  70                 break;
  71             }
  72
  73             out_p[out_base] = ACE_Byte(run_count++ | (run_code ? 0x80 : 0));
  74
  75             if (out_index >= max_out_len) {
  76                 return ACE_UINT64(-1);          // Output Exhausted
  77             }
  78             out_p[out_index++] = cur_byte;
  79         }
  80         this->update_stats(src_len, out_index);
  81     }
  82
  83     return out_index;  // return as our output length
  84 }
  85
  86 // Decompress using Run Length Encoding (RLE)
  87 ACE_UINT64
  88 ACE_RLECompressor::decompress(const void *in_ptr,
  89                               ACE_UINT64 in_len,
  90                               void *out_ptr,
  91                               ACE_UINT64 max_out_len)
  92 {
  93     ACE_UINT64  out_len     = 0;
  94
  95     const ACE_Byte *in_p    = static_cast<const ACE_Byte *>(in_ptr);
  96     ACE_Byte *out_p         = static_cast<ACE_Byte *>(out_ptr);
  97
  98     if (in_p && out_p) while(in_len-- > 0) {
  99         ACE_Byte    cur_byte    = *in_p++;
 100         ACE_UINT32  cpy_len     = ACE_UINT32((cur_byte & ACE_CHAR_MAX) + 1);
 101
 102         if (cpy_len > max_out_len) {
 103             return ACE_UINT64(-1); // Output Exhausted
 104         } else if ((cur_byte & 0x80) != 0) {  // compressed
 105             if (in_len-- > 0) {
 106                 ACE_OS::memset(out_p, *in_p++, cpy_len);
 107             } else {
 108                 return ACE_UINT64(-1); // Output Exhausted
 109             }
 110         } else if (in_len >= cpy_len) {
 111             ACE_OS::memcpy(out_p, in_p, cpy_len);
 112             in_p    += cpy_len;
 113             in_len  -= cpy_len;
 114         } else {
 115             return ACE_UINT64(-1); // Output Exhausted
 116         }
 117
 118         out_p       += cpy_len;
 119         max_out_len -= cpy_len;
 120         out_len     += cpy_len;
 121     }
 122
 123     return out_len;
 124 }
 125
 126 ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_Singleton, ACE_RLECompressor, ACE_SYNCH_MUTEX);
 127
 128 // Close versioned namespace, if enabled by the user.
 129 ACE_END_VERSIONED_NAMESPACE_DECL
 130