Mercurial > vba-linux

     1 // DeflateConst.h

     2 

     3 #ifndef __DEFLATE_CONST_H

     4 #define __DEFLATE_CONST_H

     5 

     6 namespace NCompress {

     7 namespace NDeflate {

     8 

     9 const int kNumHuffmanBits = 15;

    10 

    11 const UInt32 kHistorySize32 = (1 << 15);

    12 const UInt32 kHistorySize64 = (1 << 16);

    13 

    14 const UInt32 kDistTableSize32 = 30;

    15 const UInt32 kDistTableSize64 = 32;

    16   

    17 const UInt32 kNumLenSymbols32 = 256;

    18 const UInt32 kNumLenSymbols64 = 255; // don't change it. It must be <= 255.

    19 const UInt32 kNumLenSymbolsMax = kNumLenSymbols32;

    20   

    21 const UInt32 kNumLenSlots = 29;

    22 

    23 const UInt32 kFixedDistTableSize = 32;

    24 const UInt32 kFixedLenTableSize = 31;

    25 

    26 const UInt32 kSymbolEndOfBlock = 0x100;

    27 const UInt32 kSymbolMatch = kSymbolEndOfBlock + 1;

    28 

    29 const UInt32 kMainTableSize = kSymbolMatch + kNumLenSlots;

    30 const UInt32 kFixedMainTableSize = kSymbolMatch + kFixedLenTableSize;

    31 

    32 const UInt32 kLevelTableSize = 19;

    33 

    34 const UInt32 kTableDirectLevels = 16;

    35 const UInt32 kTableLevelRepNumber = kTableDirectLevels;

    36 const UInt32 kTableLevel0Number = kTableLevelRepNumber + 1;

    37 const UInt32 kTableLevel0Number2 = kTableLevel0Number + 1;

    38 

    39 const UInt32 kLevelMask = 0xF;

    40 

    41 const Byte kLenStart32[kFixedLenTableSize] =

    42   {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 255, 0, 0};

    43 const Byte kLenStart64[kFixedLenTableSize] =

    44   {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 0, 0, 0};

    45 

    46 const Byte kLenDirectBits32[kFixedLenTableSize] =

    47   {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5, 0, 0, 0};

    48 const Byte kLenDirectBits64[kFixedLenTableSize] =

    49   {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5, 16, 0, 0};

    50 

    51 const UInt32 kDistStart[kDistTableSize64]  =

    52   {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,

    53   1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768,49152};

    54 const Byte kDistDirectBits[kDistTableSize64] =

    55   {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14};

    56 

    57 const Byte kLevelDirectBits[3] = {2, 3, 7};

    58 

    59 const Byte kCodeLengthAlphabetOrder[kLevelTableSize] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

    60 

    61 const UInt32 kMatchMinLen = 3;

    62 const UInt32 kMatchMaxLen32 = kNumLenSymbols32 + kMatchMinLen - 1; //256 + 2

    63 const UInt32 kMatchMaxLen64 = kNumLenSymbols64 + kMatchMinLen - 1; //255 + 2

    64 const UInt32 kMatchMaxLen = kMatchMaxLen32;

    65 

    66 const int kFinalBlockFieldSize = 1;

    67 

    68 namespace NFinalBlockField

    69 {

    70   enum

    71   {

    72     kNotFinalBlock = 0,

    73     kFinalBlock = 1

    74   };

    75 }

    76 

    77 const int kBlockTypeFieldSize = 2;

    78 

    79 namespace NBlockType

    80 {

    81   enum

    82   {

    83     kStored = 0,

    84     kFixedHuffman = 1,

    85     kDynamicHuffman = 2

    86   };

    87 }

    88 

    89 const int kNumLenCodesFieldSize = 5;

    90 const int kNumDistCodesFieldSize = 5;

    91 const int kNumLevelCodesFieldSize = 4;

    92 

    93 const UInt32 kNumLitLenCodesMin = 257;

    94 const UInt32 kNumDistCodesMin = 1;

    95 const UInt32 kNumLevelCodesMin = 4;

    96 

    97 const int kLevelFieldSize = 3;

    98 

    99 const int kStoredBlockLengthFieldSize = 16;

   100 

   101 struct CLevels

   102 {

   103   Byte litLenLevels[kFixedMainTableSize];

   104   Byte distLevels[kFixedDistTableSize];

   105 

   106   void SubClear()

   107   {

   108     UInt32 i;

   109     for(i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)

   110       litLenLevels[i] = 0;

   111     for(i = 0; i < kFixedDistTableSize; i++)

   112       distLevels[i] = 0;

   113   }

   114 

   115   void SetFixedLevels()

   116   {

   117     int i;

   118     

   119     for (i = 0; i < 144; i++)

   120       litLenLevels[i] = 8;

   121     for (; i < 256; i++)

   122       litLenLevels[i] = 9;

   123     for (; i < 280; i++)

   124       litLenLevels[i] = 7;

   125     for (; i < 288; i++)

   126       litLenLevels[i] = 8;

   127     for (i = 0; i < kFixedDistTableSize; i++)  // test it: InfoZip only uses kDistTableSize

   128       distLevels[i] = 5;

   129   }

   130 };

   131 

   132 }}

   133 

   134 #endif
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 03 Mar 2012 10:31:27 -0600
parents
children