zlib123/example.c
Go to the documentation of this file.
1 /* example.c -- usage example of the zlib compression library
2  * Copyright (C) 1995-2004 Jean-loup Gailly.
3  * For conditions of distribution and use, see copyright notice in zlib.h
4  */
5 
6 /* @(#) $Id$ */
7 
8 #include <stdio.h>
9 #include "zlib.h"
10 
11 #ifdef STDC
12 # include <string.h>
13 # include <stdlib.h>
14 #endif
15 
16 #if defined(VMS) || defined(RISCOS)
17 # define TESTFILE "foo-gz"
18 #else
19 # define TESTFILE "foo.gz"
20 #endif
21 
22 #define CHECK_ERR(err, msg) { \
23  if (err != Z_OK) { \
24  fprintf(stderr, "%s error: %d\n", msg, err); \
25  exit(1); \
26  } \
27 }
28 
29 const char hello[] = "hello, hello!";
30 /* "hello world" would be more standard, but the repeated "hello"
31  * stresses the compression code better, sorry...
32  */
33 
34 const char dictionary[] = "hello";
35 uLong dictId; /* Adler32 value of the dictionary */
36 
37 void test_compress OF((Byte *compr, uLong comprLen,
38  Byte *uncompr, uLong uncomprLen));
39 void test_gzio OF((const char *fname,
40  Byte *uncompr, uLong uncomprLen));
41 void test_deflate OF((Byte *compr, uLong comprLen));
42 void test_inflate OF((Byte *compr, uLong comprLen,
43  Byte *uncompr, uLong uncomprLen));
44 void test_large_deflate OF((Byte *compr, uLong comprLen,
45  Byte *uncompr, uLong uncomprLen));
46 void test_large_inflate OF((Byte *compr, uLong comprLen,
47  Byte *uncompr, uLong uncomprLen));
48 void test_flush OF((Byte *compr, uLong *comprLen));
49 void test_sync OF((Byte *compr, uLong comprLen,
50  Byte *uncompr, uLong uncomprLen));
51 void test_dict_deflate OF((Byte *compr, uLong comprLen));
52 void test_dict_inflate OF((Byte *compr, uLong comprLen,
53  Byte *uncompr, uLong uncomprLen));
54 int main OF((int argc, char *argv[]));
55 
56 /* ===========================================================================
57  * Test compress() and uncompress()
58  */
59 void test_compress(compr, comprLen, uncompr, uncomprLen)
60  Byte *compr, *uncompr;
61  uLong comprLen, uncomprLen;
62 {
63  int err;
64  uLong len = (uLong)strlen(hello)+1;
65 
66  err = compress(compr, &comprLen, (const Bytef*)hello, len);
67  CHECK_ERR(err, "compress");
68 
69  strcpy((char*)uncompr, "garbage");
70 
71  err = uncompress(uncompr, &uncomprLen, compr, comprLen);
72  CHECK_ERR(err, "uncompress");
73 
74  if (strcmp((char*)uncompr, hello)) {
75  fprintf(stderr, "bad uncompress\n");
76  exit(1);
77  } else {
78  printf("uncompress(): %s\n", (char *)uncompr);
79  }
80 }
81 
82 /* ===========================================================================
83  * Test read/write of .gz files
84  */
85 void test_gzio(fname, uncompr, uncomprLen)
86  const char *fname; /* compressed file name */
87  Byte *uncompr;
88  uLong uncomprLen;
89 {
90 #ifdef NO_GZCOMPRESS
91  fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
92 #else
93  int err;
94  int len = (int)strlen(hello)+1;
95  gzFile file;
96  z_off_t pos;
97 
98  file = gzopen(fname, "wb");
99  if (file == NULL) {
100  fprintf(stderr, "gzopen error\n");
101  exit(1);
102  }
103  gzputc(file, 'h');
104  if (gzputs(file, "ello") != 4) {
105  fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
106  exit(1);
107  }
108  if (gzprintf(file, ", %s!", "hello") != 8) {
109  fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
110  exit(1);
111  }
112  gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
113  gzclose(file);
114 
115  file = gzopen(fname, "rb");
116  if (file == NULL) {
117  fprintf(stderr, "gzopen error\n");
118  exit(1);
119  }
120  strcpy((char*)uncompr, "garbage");
121 
122  if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
123  fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
124  exit(1);
125  }
126  if (strcmp((char*)uncompr, hello)) {
127  fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
128  exit(1);
129  } else {
130  printf("gzread(): %s\n", (char*)uncompr);
131  }
132 
133  pos = gzseek(file, -8L, SEEK_CUR);
134  if (pos != 6 || gztell(file) != pos) {
135  fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
136  (long)pos, (long)gztell(file));
137  exit(1);
138  }
139 
140  if (gzgetc(file) != ' ') {
141  fprintf(stderr, "gzgetc error\n");
142  exit(1);
143  }
144 
145  if (gzungetc(' ', file) != ' ') {
146  fprintf(stderr, "gzungetc error\n");
147  exit(1);
148  }
149 
150  gzgets(file, (char*)uncompr, (int)uncomprLen);
151  if (strlen((char*)uncompr) != 7) { /* " hello!" */
152  fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
153  exit(1);
154  }
155  if (strcmp((char*)uncompr, hello + 6)) {
156  fprintf(stderr, "bad gzgets after gzseek\n");
157  exit(1);
158  } else {
159  printf("gzgets() after gzseek: %s\n", (char*)uncompr);
160  }
161 
162  gzclose(file);
163 #endif
164 }
165 
166 /* ===========================================================================
167  * Test deflate() with small buffers
168  */
169 void test_deflate(compr, comprLen)
170  Byte *compr;
171  uLong comprLen;
172 {
173  z_stream c_stream; /* compression stream */
174  int err;
175  uLong len = (uLong)strlen(hello)+1;
176 
177  c_stream.zalloc = (alloc_func)0;
178  c_stream.zfree = (free_func)0;
179  c_stream.opaque = (voidpf)0;
180 
181  err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
182  CHECK_ERR(err, "deflateInit");
183 
184  c_stream.next_in = (Bytef*)hello;
185  c_stream.next_out = compr;
186 
187  while (c_stream.total_in != len && c_stream.total_out < comprLen) {
188  c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
189  err = deflate(&c_stream, Z_NO_FLUSH);
190  CHECK_ERR(err, "deflate");
191  }
192  /* Finish the stream, still forcing small buffers: */
193  for (;;) {
194  c_stream.avail_out = 1;
195  err = deflate(&c_stream, Z_FINISH);
196  if (err == Z_STREAM_END) break;
197  CHECK_ERR(err, "deflate");
198  }
199 
200  err = deflateEnd(&c_stream);
201  CHECK_ERR(err, "deflateEnd");
202 }
203 
204 /* ===========================================================================
205  * Test inflate() with small buffers
206  */
207 void test_inflate(compr, comprLen, uncompr, uncomprLen)
208  Byte *compr, *uncompr;
209  uLong comprLen, uncomprLen;
210 {
211  int err;
212  z_stream d_stream; /* decompression stream */
213 
214  strcpy((char*)uncompr, "garbage");
215 
216  d_stream.zalloc = (alloc_func)0;
217  d_stream.zfree = (free_func)0;
218  d_stream.opaque = (voidpf)0;
219 
220  d_stream.next_in = compr;
221  d_stream.avail_in = 0;
222  d_stream.next_out = uncompr;
223 
224  err = inflateInit(&d_stream);
225  CHECK_ERR(err, "inflateInit");
226 
227  while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
228  d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
229  err = inflate(&d_stream, Z_NO_FLUSH);
230  if (err == Z_STREAM_END) break;
231  CHECK_ERR(err, "inflate");
232  }
233 
234  err = inflateEnd(&d_stream);
235  CHECK_ERR(err, "inflateEnd");
236 
237  if (strcmp((char*)uncompr, hello)) {
238  fprintf(stderr, "bad inflate\n");
239  exit(1);
240  } else {
241  printf("inflate(): %s\n", (char *)uncompr);
242  }
243 }
244 
245 /* ===========================================================================
246  * Test deflate() with large buffers and dynamic change of compression level
247  */
248 void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
249  Byte *compr, *uncompr;
250  uLong comprLen, uncomprLen;
251 {
252  z_stream c_stream; /* compression stream */
253  int err;
254 
255  c_stream.zalloc = (alloc_func)0;
256  c_stream.zfree = (free_func)0;
257  c_stream.opaque = (voidpf)0;
258 
259  err = deflateInit(&c_stream, Z_BEST_SPEED);
260  CHECK_ERR(err, "deflateInit");
261 
262  c_stream.next_out = compr;
263  c_stream.avail_out = (uInt)comprLen;
264 
265  /* At this point, uncompr is still mostly zeroes, so it should compress
266  * very well:
267  */
268  c_stream.next_in = uncompr;
269  c_stream.avail_in = (uInt)uncomprLen;
270  err = deflate(&c_stream, Z_NO_FLUSH);
271  CHECK_ERR(err, "deflate");
272  if (c_stream.avail_in != 0) {
273  fprintf(stderr, "deflate not greedy\n");
274  exit(1);
275  }
276 
277  /* Feed in already compressed data and switch to no compression: */
279  c_stream.next_in = compr;
280  c_stream.avail_in = (uInt)comprLen/2;
281  err = deflate(&c_stream, Z_NO_FLUSH);
282  CHECK_ERR(err, "deflate");
283 
284  /* Switch back to compressing mode: */
286  c_stream.next_in = uncompr;
287  c_stream.avail_in = (uInt)uncomprLen;
288  err = deflate(&c_stream, Z_NO_FLUSH);
289  CHECK_ERR(err, "deflate");
290 
291  err = deflate(&c_stream, Z_FINISH);
292  if (err != Z_STREAM_END) {
293  fprintf(stderr, "deflate should report Z_STREAM_END\n");
294  exit(1);
295  }
296  err = deflateEnd(&c_stream);
297  CHECK_ERR(err, "deflateEnd");
298 }
299 
300 /* ===========================================================================
301  * Test inflate() with large buffers
302  */
303 void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
304  Byte *compr, *uncompr;
305  uLong comprLen, uncomprLen;
306 {
307  int err;
308  z_stream d_stream; /* decompression stream */
309 
310  strcpy((char*)uncompr, "garbage");
311 
312  d_stream.zalloc = (alloc_func)0;
313  d_stream.zfree = (free_func)0;
314  d_stream.opaque = (voidpf)0;
315 
316  d_stream.next_in = compr;
317  d_stream.avail_in = (uInt)comprLen;
318 
319  err = inflateInit(&d_stream);
320  CHECK_ERR(err, "inflateInit");
321 
322  for (;;) {
323  d_stream.next_out = uncompr; /* discard the output */
324  d_stream.avail_out = (uInt)uncomprLen;
325  err = inflate(&d_stream, Z_NO_FLUSH);
326  if (err == Z_STREAM_END) break;
327  CHECK_ERR(err, "large inflate");
328  }
329 
330  err = inflateEnd(&d_stream);
331  CHECK_ERR(err, "inflateEnd");
332 
333  if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
334  fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
335  exit(1);
336  } else {
337  printf("large_inflate(): OK\n");
338  }
339 }
340 
341 /* ===========================================================================
342  * Test deflate() with full flush
343  */
344 void test_flush(compr, comprLen)
345  Byte *compr;
346  uLong *comprLen;
347 {
348  z_stream c_stream; /* compression stream */
349  int err;
350  uInt len = (uInt)strlen(hello)+1;
351 
352  c_stream.zalloc = (alloc_func)0;
353  c_stream.zfree = (free_func)0;
354  c_stream.opaque = (voidpf)0;
355 
356  err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
357  CHECK_ERR(err, "deflateInit");
358 
359  c_stream.next_in = (Bytef*)hello;
360  c_stream.next_out = compr;
361  c_stream.avail_in = 3;
362  c_stream.avail_out = (uInt)*comprLen;
363  err = deflate(&c_stream, Z_FULL_FLUSH);
364  CHECK_ERR(err, "deflate");
365 
366  compr[3]++; /* force an error in first compressed block */
367  c_stream.avail_in = len - 3;
368 
369  err = deflate(&c_stream, Z_FINISH);
370  if (err != Z_STREAM_END) {
371  CHECK_ERR(err, "deflate");
372  }
373  err = deflateEnd(&c_stream);
374  CHECK_ERR(err, "deflateEnd");
375 
376  *comprLen = c_stream.total_out;
377 }
378 
379 /* ===========================================================================
380  * Test inflateSync()
381  */
382 void test_sync(compr, comprLen, uncompr, uncomprLen)
383  Byte *compr, *uncompr;
384  uLong comprLen, uncomprLen;
385 {
386  int err;
387  z_stream d_stream; /* decompression stream */
388 
389  strcpy((char*)uncompr, "garbage");
390 
391  d_stream.zalloc = (alloc_func)0;
392  d_stream.zfree = (free_func)0;
393  d_stream.opaque = (voidpf)0;
394 
395  d_stream.next_in = compr;
396  d_stream.avail_in = 2; /* just read the zlib header */
397 
398  err = inflateInit(&d_stream);
399  CHECK_ERR(err, "inflateInit");
400 
401  d_stream.next_out = uncompr;
402  d_stream.avail_out = (uInt)uncomprLen;
403 
404  inflate(&d_stream, Z_NO_FLUSH);
405  CHECK_ERR(err, "inflate");
406 
407  d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
408  err = inflateSync(&d_stream); /* but skip the damaged part */
409  CHECK_ERR(err, "inflateSync");
410 
411  err = inflate(&d_stream, Z_FINISH);
412  if (err != Z_DATA_ERROR) {
413  fprintf(stderr, "inflate should report DATA_ERROR\n");
414  /* Because of incorrect adler32 */
415  exit(1);
416  }
417  err = inflateEnd(&d_stream);
418  CHECK_ERR(err, "inflateEnd");
419 
420  printf("after inflateSync(): hel%s\n", (char *)uncompr);
421 }
422 
423 /* ===========================================================================
424  * Test deflate() with preset dictionary
425  */
426 void test_dict_deflate(compr, comprLen)
427  Byte *compr;
428  uLong comprLen;
429 {
430  z_stream c_stream; /* compression stream */
431  int err;
432 
433  c_stream.zalloc = (alloc_func)0;
434  c_stream.zfree = (free_func)0;
435  c_stream.opaque = (voidpf)0;
436 
437  err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
438  CHECK_ERR(err, "deflateInit");
439 
440  err = deflateSetDictionary(&c_stream,
441  (const Bytef*)dictionary, sizeof(dictionary));
442  CHECK_ERR(err, "deflateSetDictionary");
443 
444  dictId = c_stream.adler;
445  c_stream.next_out = compr;
446  c_stream.avail_out = (uInt)comprLen;
447 
448  c_stream.next_in = (Bytef*)hello;
449  c_stream.avail_in = (uInt)strlen(hello)+1;
450 
451  err = deflate(&c_stream, Z_FINISH);
452  if (err != Z_STREAM_END) {
453  fprintf(stderr, "deflate should report Z_STREAM_END\n");
454  exit(1);
455  }
456  err = deflateEnd(&c_stream);
457  CHECK_ERR(err, "deflateEnd");
458 }
459 
460 /* ===========================================================================
461  * Test inflate() with a preset dictionary
462  */
463 void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
464  Byte *compr, *uncompr;
465  uLong comprLen, uncomprLen;
466 {
467  int err;
468  z_stream d_stream; /* decompression stream */
469 
470  strcpy((char*)uncompr, "garbage");
471 
472  d_stream.zalloc = (alloc_func)0;
473  d_stream.zfree = (free_func)0;
474  d_stream.opaque = (voidpf)0;
475 
476  d_stream.next_in = compr;
477  d_stream.avail_in = (uInt)comprLen;
478 
479  err = inflateInit(&d_stream);
480  CHECK_ERR(err, "inflateInit");
481 
482  d_stream.next_out = uncompr;
483  d_stream.avail_out = (uInt)uncomprLen;
484 
485  for (;;) {
486  err = inflate(&d_stream, Z_NO_FLUSH);
487  if (err == Z_STREAM_END) break;
488  if (err == Z_NEED_DICT) {
489  if (d_stream.adler != dictId) {
490  fprintf(stderr, "unexpected dictionary");
491  exit(1);
492  }
493  err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
494  sizeof(dictionary));
495  }
496  CHECK_ERR(err, "inflate with dict");
497  }
498 
499  err = inflateEnd(&d_stream);
500  CHECK_ERR(err, "inflateEnd");
501 
502  if (strcmp((char*)uncompr, hello)) {
503  fprintf(stderr, "bad inflate with dict\n");
504  exit(1);
505  } else {
506  printf("inflate with dictionary: %s\n", (char *)uncompr);
507  }
508 }
509 
510 /* ===========================================================================
511  * Usage: example [output.gz [input.gz]]
512  */
513 
514 int main(argc, argv)
515  int argc;
516  char *argv[];
517 {
518  Byte *compr, *uncompr;
519  uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
520  uLong uncomprLen = comprLen;
521  static const char* myVersion = ZLIB_VERSION;
522 
523  if (zlibVersion()[0] != myVersion[0]) {
524  fprintf(stderr, "incompatible zlib version\n");
525  exit(1);
526 
527  } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
528  fprintf(stderr, "warning: different zlib version\n");
529  }
530 
531  printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
533 
534  compr = (Byte*)calloc((uInt)comprLen, 1);
535  uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
536  /* compr and uncompr are cleared to avoid reading uninitialized
537  * data and to ensure that uncompr compresses well.
538  */
539  if (compr == Z_NULL || uncompr == Z_NULL) {
540  printf("out of memory\n");
541  exit(1);
542  }
543  test_compress(compr, comprLen, uncompr, uncomprLen);
544 
545  test_gzio((argc > 1 ? argv[1] : TESTFILE),
546  uncompr, uncomprLen);
547 
548  test_deflate(compr, comprLen);
549  test_inflate(compr, comprLen, uncompr, uncomprLen);
550 
551  test_large_deflate(compr, comprLen, uncompr, uncomprLen);
552  test_large_inflate(compr, comprLen, uncompr, uncomprLen);
553 
554  test_flush(compr, &comprLen);
555  test_sync(compr, comprLen, uncompr, uncomprLen);
556  comprLen = uncomprLen;
557 
558  test_dict_deflate(compr, comprLen);
559  test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
560 
561  free(compr);
562  free(uncompr);
563 
564  return 0;
565 }
int ZEXPORT gzgetc(gzFile file)
Definition: gzio.c:503
void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
Definition: deflate.c:416
void test_gzio(char *fname, Byte *uncompr, uLong uncomprLen) const
Byte FAR * voidpf
Definition: zconf.h:283
char *ZEXPORT gzgets(gzFile file, char *buf, int len)
Definition: gzio.c:540
Bytef * next_in
Definition: zlib.h:83
#define SEEK_CUR
Definition: zconf.h:297
unsigned char Byte
Definition: zconf.h:261
#define Z_NO_FLUSH
Definition: zlib.h:162
int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: uncompr.c:26
#define Z_BEST_COMPRESSION
Definition: zlib.h:185
#define z_off_t
Definition: zconf.h:301
uInt avail_in
Definition: zlib.h:84
#define Z_NEED_DICT
Definition: zlib.h:172
int ZEXPORT gzread(gzFile file, voidp buf, unsigned len)
Definition: gzio.c:394
unsigned long uLong
Definition: zconf.h:264
const char *ZEXPORT zlibVersion()
Definition: zutil.c:27
int ZEXPORT deflateEnd(z_streamp strm)
Definition: deflate.c:859
#define Z_FILTERED
Definition: zlib.h:189
int ZEXPORT gzungetc(int c, gzFile file)
Definition: gzio.c:515
int main(int argc, argv)
#define CHECK_ERR(err, msg)
Byte FAR Bytef
Definition: zconf.h:270
voidpf opaque
Definition: zlib.h:96
int ZEXPORT gzclose(gzFile file)
Definition: gzio.c:953
voidp gzFile
Definition: zlib.h:1066
free_func zfree
Definition: zlib.h:95
int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
Definition: inflate.c:1169
gzFile ZEXPORT gzopen(char *path, const char *mode) const
Definition: gzio.c:208
#define Z_FINISH
Definition: zlib.h:166
void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
const char *ZEXPORT gzerror(gzFile file, int *errnum)
Definition: gzio.c:987
#define Z_DATA_ERROR
Definition: zlib.h:175
uLong ZEXPORT zlibCompileFlags()
Definition: zutil.c:32
uLong total_in
Definition: zlib.h:85
#define Z_STREAM_END
Definition: zlib.h:171
int ZEXPORTVA gzprintf(gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
Definition: gzio.c:637
alloc_func zalloc
Definition: zlib.h:94
int free()
Bytef * next_out
Definition: zlib.h:87
void test_compress(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
int ZEXPORT gzputs(gzFile file, const char *s)
Definition: gzio.c:693
const char hello[]
int ZEXPORT inflateSync(z_streamp strm)
Definition: inflate.c:1262
int ZEXPORT deflate(z_streamp strm, int flush)
Definition: deflate.c:552
#define ZLIB_VERSION
Definition: zlib.h:40
uLong adler
Definition: zlib.h:99
#define Z_BEST_SPEED
Definition: zlib.h:184
uLong total_out
Definition: zlib.h:89
typedef int
Definition: png.h:1113
z_off_t ZEXPORT gztell(gzFile file)
Definition: gzio.c:881
uLong dictId
#define TESTFILE
#define ZLIB_VERNUM
Definition: zlib.h:41
int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: compress.c:62
int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
Definition: deflate.c:315
#define deflateInit(strm, level)
Definition: zlib.h:1331
#define inflateInit(strm)
Definition: zlib.h:1333
uInt avail_out
Definition: zlib.h:88
#define Z_NO_COMPRESSION
Definition: zlib.h:183
void test_dict_deflate(Byte *compr, uLong comprLen)
void test_deflate(Byte *compr, uLong comprLen)
int ZEXPORT inflate(z_streamp strm, int flush)
Definition: inflate.c:554
#define Z_DEFAULT_STRATEGY
Definition: zlib.h:193
#define Z_NULL
Definition: zlib.h:205
#define Z_FULL_FLUSH
Definition: zlib.h:165
#define const
Definition: zconf.h:124
z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
Definition: gzio.c:767
void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
int ZEXPORT inflateEnd(z_streamp strm)
Definition: inflate.c:1155
int ZEXPORT gzputc(gzFile file, int c)
Definition: gzio.c:678
void test_flush(Byte *compr, uLong *comprLen)
#define Z_DEFAULT_COMPRESSION
Definition: zlib.h:186
unsigned int uInt
Definition: zconf.h:263
const char dictionary[]
void test_compress OF((Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen))


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat May 8 2021 02:42:37