Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/zlib/include/deflate.h

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /externals/zlib/include/deflate.h (Version 11.3.0) and /externals/zlib/include/deflate.h (Version 10.1.p3)


  1 /* deflate.h -- internal compression state          1 
  2  * Copyright (C) 1995-2018 Jean-loup Gailly       
  3  * For conditions of distribution and use, see    
  4  */                                               
  5                                                   
  6 /* WARNING: this file should *not* be used by     
  7    part of the implementation of the compressi    
  8    subject to change. Applications should only    
  9  */                                               
 10                                                   
 11 /* @(#) $Id$ */                                   
 12                                                   
 13 #ifndef DEFLATE_H                                 
 14 #define DEFLATE_H                                 
 15                                                   
 16 #include "zutil.h"                                
 17                                                   
 18 /* define NO_GZIP when compiling if you want t    
 19    trailer creation by deflate().  NO_GZIP wou    
 20    the crc code when it is not needed.  For sh    
 21    should be left enabled. */                     
 22 #ifndef NO_GZIP                                   
 23 #  define GZIP                                    
 24 #endif                                            
 25                                                   
 26 /* ===========================================    
 27  * Internal compression state.                    
 28  */                                               
 29                                                   
 30 #define LENGTH_CODES 29                           
 31 /* number of length codes, not counting the sp    
 32                                                   
 33 #define LITERALS  256                             
 34 /* number of literal bytes 0..255 */              
 35                                                   
 36 #define L_CODES (LITERALS+1+LENGTH_CODES)         
 37 /* number of Literal or Length codes, includin    
 38                                                   
 39 #define D_CODES   30                              
 40 /* number of distance codes */                    
 41                                                   
 42 #define BL_CODES  19                              
 43 /* number of codes used to transfer the bit le    
 44                                                   
 45 #define HEAP_SIZE (2*L_CODES+1)                   
 46 /* maximum heap size */                           
 47                                                   
 48 #define MAX_BITS 15                               
 49 /* All codes must not exceed MAX_BITS bits */     
 50                                                   
 51 #define Buf_size 16                               
 52 /* size of bit buffer in bi_buf */                
 53                                                   
 54 #define INIT_STATE    42    /* zlib header ->     
 55 #ifdef GZIP                                       
 56 #  define GZIP_STATE  57    /* gzip header ->     
 57 #endif                                            
 58 #define EXTRA_STATE   69    /* gzip extra bloc    
 59 #define NAME_STATE    73    /* gzip file name     
 60 #define COMMENT_STATE 91    /* gzip comment ->    
 61 #define HCRC_STATE   103    /* gzip header CRC    
 62 #define BUSY_STATE   113    /* deflate -> FINI    
 63 #define FINISH_STATE 666    /* stream complete    
 64 /* Stream status */                               
 65                                                   
 66                                                   
 67 /* Data structure describing a single value an    
 68 typedef struct ct_data_s {                        
 69     union {                                       
 70         ush  freq;       /* frequency count */    
 71         ush  code;       /* bit string */         
 72     } fc;                                         
 73     union {                                       
 74         ush  dad;        /* father node in Huf    
 75         ush  len;        /* length of bit stri    
 76     } dl;                                         
 77 } FAR ct_data;                                    
 78                                                   
 79 #define Freq fc.freq                              
 80 #define Code fc.code                              
 81 #define Dad  dl.dad                               
 82 #define Len  dl.len                               
 83                                                   
 84 typedef struct static_tree_desc_s  static_tree    
 85                                                   
 86 typedef struct tree_desc_s {                      
 87     ct_data *dyn_tree;           /* the dynami    
 88     int     max_code;            /* largest co    
 89     const static_tree_desc *stat_desc;  /* the    
 90 } FAR tree_desc;                                  
 91                                                   
 92 typedef ush Pos;                                  
 93 typedef Pos FAR Posf;                             
 94 typedef unsigned IPos;                            
 95                                                   
 96 /* A Pos is an index in the character window.     
 97  * save space in the various tables. IPos is u    
 98  */                                               
 99                                                   
100 typedef struct internal_state {                   
101     z_streamp strm;      /* pointer back to th    
102     int   status;        /* as the name implie    
103     Bytef *pending_buf;  /* output still pendi    
104     ulg   pending_buf_size; /* size of pending    
105     Bytef *pending_out;  /* next pending byte     
106     ulg   pending;       /* nb of bytes in the    
107     int   wrap;          /* bit 0 true for zli    
108     gz_headerp  gzhead;  /* gzip header inform    
109     ulg   gzindex;       /* where in extra, na    
110     Byte  method;        /* can only be DEFLAT    
111     int   last_flush;    /* value of flush par    
112                                                   
113                 /* used by deflate.c: */          
114                                                   
115     uInt  w_size;        /* LZ77 window size (    
116     uInt  w_bits;        /* log2(w_size)  (8..    
117     uInt  w_mask;        /* w_size - 1 */         
118                                                   
119     Bytef *window;                                
120     /* Sliding window. Input bytes are read in    
121      * and move to the first half later to kee    
122      * bytes. With this organization, matches     
123      * wSize-MAX_MATCH bytes, but this ensures    
124      * performed with a length multiple of the    
125      * the window size to 64K, which is quite     
126      * To do: use the user input buffer as sli    
127      */                                           
128                                                   
129     ulg window_size;                              
130     /* Actual size of window: 2*wSize, except     
131      * is directly used as sliding window.        
132      */                                           
133                                                   
134     Posf *prev;                                   
135     /* Link to older string with same hash ind    
136      * array to 64K, this link is maintained o    
137      * An index in this array is thus a window    
138      */                                           
139                                                   
140     Posf *head; /* Heads of the hash chains or    
141                                                   
142     uInt  ins_h;          /* hash index of str    
143     uInt  hash_size;      /* number of element    
144     uInt  hash_bits;      /* log2(hash_size) *    
145     uInt  hash_mask;      /* hash_size-1 */       
146                                                   
147     uInt  hash_shift;                             
148     /* Number of bits by which ins_h must be s    
149      * step. It must be such that after MIN_MA    
150      * byte no longer takes part in the hash k    
151      *   hash_shift * MIN_MATCH >= hash_bits      
152      */                                           
153                                                   
154     long block_start;                             
155     /* Window position at the beginning of the    
156      * negative when the window is moved backw    
157      */                                           
158                                                   
159     uInt match_length;           /* length of     
160     IPos prev_match;             /* previous m    
161     int match_available;         /* set if pre    
162     uInt strstart;               /* start of s    
163     uInt match_start;            /* start of m    
164     uInt lookahead;              /* number of     
165                                                   
166     uInt prev_length;                             
167     /* Length of the best match at previous st    
168      * are discarded. This is used in the lazy    
169      */                                           
170                                                   
171     uInt max_chain_length;                        
172     /* To speed up deflation, hash chains are     
173      * length.  A higher limit improves compre    
174      * speed.                                     
175      */                                           
176                                                   
177     uInt max_lazy_match;                          
178     /* Attempt to find a better match only whe    
179      * smaller than this value. This mechanism    
180      * levels >= 4.                               
181      */                                           
182 #   define max_insert_length  max_lazy_match      
183     /* Insert new strings in the hash table on    
184      * greater than this length. This saves ti    
185      * max_insert_length is used only for comp    
186      */                                           
187                                                   
188     int level;    /* compression level (1..9)     
189     int strategy; /* favor or force Huffman co    
190                                                   
191     uInt good_match;                              
192     /* Use a faster search when the previous m    
193                                                   
194     int nice_match; /* Stop searching when cur    
195                                                   
196                 /* used by trees.c: */            
197     /* Didn't use ct_data typedef below to sup    
198     struct ct_data_s dyn_ltree[HEAP_SIZE];   /    
199     struct ct_data_s dyn_dtree[2*D_CODES+1]; /    
200     struct ct_data_s bl_tree[2*BL_CODES+1];  /    
201                                                   
202     struct tree_desc_s l_desc;               /    
203     struct tree_desc_s d_desc;               /    
204     struct tree_desc_s bl_desc;              /    
205                                                   
206     ush bl_count[MAX_BITS+1];                     
207     /* number of codes at each bit length for     
208                                                   
209     int heap[2*L_CODES+1];      /* heap used t    
210     int heap_len;               /* number of e    
211     int heap_max;               /* element of     
212     /* The sons of heap[n] are heap[2*n] and h    
213      * The same heap array is used to build al    
214      */                                           
215                                                   
216     uch depth[2*L_CODES+1];                       
217     /* Depth of each subtree used as tie break    
218      */                                           
219                                                   
220     uchf *sym_buf;        /* buffer for distan    
221                                                   
222     uInt  lit_bufsize;                            
223     /* Size of match buffer for literals/lengt    
224      * limiting lit_bufsize to 64K:               
225      *   - frequencies can be kept in 16 bit c    
226      *   - if compression is not successful fo    
227      *     data is still in the window so we c    
228      *     when input comes from standard inpu    
229      *     all blocks if lit_bufsize is not gr    
230      *   - if compression is not successful fo    
231      *     even emit a stored file instead of     
232      *     This is applicable only for zip (no    
233      *   - creating new Huffman trees less fre    
234      *     adaptation to changes in the input     
235      *     example a binary file with poorly c    
236      *     a highly compressible string table.    
237      *     fast adaptation but have of course     
238      *     trees more frequently.                 
239      *   - I can't count above 4                  
240      */                                           
241                                                   
242     uInt sym_next;      /* running index in sy    
243     uInt sym_end;       /* symbol table full w    
244                                                   
245     ulg opt_len;        /* bit length of curre    
246     ulg static_len;     /* bit length of curre    
247     uInt matches;       /* number of string ma    
248     uInt insert;        /* bytes at end of win    
249                                                   
250 #ifdef ZLIB_DEBUG                                 
251     ulg compressed_len; /* total bit length of    
252     ulg bits_sent;      /* bit length of compr    
253 #endif                                            
254                                                   
255     ush bi_buf;                                   
256     /* Output buffer. bits are inserted starti    
257      * significant bits).                         
258      */                                           
259     int bi_valid;                                 
260     /* Number of valid bits in bi_buf.  All bi    
261      * are always zero.                           
262      */                                           
263                                                   
264     ulg high_water;                               
265     /* High water mark offset in window for in    
266      * this are set to zero in order to avoid     
267      * longest match routines access bytes pas    
268      * updated to the new high water mark.        
269      */                                           
270                                                   
271 } FAR deflate_state;                              
272                                                   
273 /* Output a byte on the stream.                   
274  * IN assertion: there is enough room in pendi    
275  */                                               
276 #define put_byte(s, c) {s->pending_buf[s->pend    
277                                                   
278                                                   
279 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)     
280 /* Minimum amount of lookahead, except at the     
281  * See deflate.c for comments about the MIN_MA    
282  */                                               
283                                                   
284 #define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEA    
285 /* In order to simplify the code, particularly    
286  * distances are limited to MAX_DIST instead o    
287  */                                               
288                                                   
289 #define WIN_INIT MAX_MATCH                        
290 /* Number of bytes after end of data in window    
291    memory checker errors from longest match ro    
292                                                   
293         /* in trees.c */                          
294 void ZLIB_INTERNAL _tr_init OF((deflate_state     
295 int ZLIB_INTERNAL _tr_tally OF((deflate_state     
296 void ZLIB_INTERNAL _tr_flush_block OF((deflate    
297                         ulg stored_len, int la    
298 void ZLIB_INTERNAL _tr_flush_bits OF((deflate_    
299 void ZLIB_INTERNAL _tr_align OF((deflate_state    
300 void ZLIB_INTERNAL _tr_stored_block OF((deflat    
301                         ulg stored_len, int la    
302                                                   
303 #define d_code(dist) \                            
304    ((dist) < 256 ? _dist_code[dist] : _dist_co    
305 /* Mapping from a distance to a distance code.    
306  * must not have side effects. _dist_code[256]    
307  * used.                                          
308  */                                               
309                                                   
310 #ifndef ZLIB_DEBUG                                
311 /* Inline versions of _tr_tally for speed: */     
312                                                   
313 #if defined(GEN_TREES_H) || !defined(STDC)        
314   extern uch ZLIB_INTERNAL _length_code[];        
315   extern uch ZLIB_INTERNAL _dist_code[];          
316 #else                                             
317   extern const uch ZLIB_INTERNAL _length_code[    
318   extern const uch ZLIB_INTERNAL _dist_code[];    
319 #endif                                            
320                                                   
321 # define _tr_tally_lit(s, c, flush) \             
322   { uch cc = (c); \                               
323     s->sym_buf[s->sym_next++] = 0; \              
324     s->sym_buf[s->sym_next++] = 0; \              
325     s->sym_buf[s->sym_next++] = cc; \             
326     s->dyn_ltree[cc].Freq++; \                    
327     flush = (s->sym_next == s->sym_end); \        
328    }                                              
329 # define _tr_tally_dist(s, distance, length, f    
330   { uch len = (uch)(length); \                    
331     ush dist = (ush)(distance); \                 
332     s->sym_buf[s->sym_next++] = (uch)dist; \      
333     s->sym_buf[s->sym_next++] = (uch)(dist >>     
334     s->sym_buf[s->sym_next++] = len; \            
335     dist--; \                                     
336     s->dyn_ltree[_length_code[len]+LITERALS+1]    
337     s->dyn_dtree[d_code(dist)].Freq++; \          
338     flush = (s->sym_next == s->sym_end); \        
339   }                                               
340 #else                                             
341 # define _tr_tally_lit(s, c, flush) flush = _t    
342 # define _tr_tally_dist(s, distance, length, f    
343               flush = _tr_tally(s, distance, l    
344 #endif                                            
345                                                   
346 #endif /* DEFLATE_H */                            
347