Category

Development Platform
Home > SourceCode/Document > Compress-Decompress algrithms > View Code
compressao_zlib.c
Package: list_compress.zip　[view]
Upload User: syzginfo
Upload Date: 2021-02-26
Package Size: 2k
Code Size: 4k
Category:

Compress-Decompress algrithms

Development Platform:

C/C++

compressao_zlib.c：Code Content
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <assert.h>
  4. #include <zlib.h>
  5.  
  6. #define CHUNK 16384
  7.  
  8. /* Comprime de 'source' para 'dest' até o fim do buffer de arquivo
  9.    inf() retorna Z_OK caso tudo ocorra bem, Z_MEM_ERROR se a memória nao pode
  10.    ser alocada, Z_DATA_ERROR se o arquivo source contem erros(invalido ou
  11.    imcompleto), Z_STREAM_ERROR se a taxa(level) de compressao estiver indisponivel,
  12.    Z_VERSION_ERROR se a versao do cabeçalho zlib.h e a versao da biblioteca
  13.    estatica nao batem, ou Z_ERRNO se há um erro ao ler ou escrever
  14.    os arquivos */
  15.  
  16. int comprime(FILE *source, FILE *dest, int level)
  17. {
  18.     int ret, flush;
  19.     unsigned have;
  20.     z_stream strm;
  21.     unsigned char in[CHUNK];
  22.     unsigned char out[CHUNK];
  24.     strm.zalloc = Z_NULL;
  25.     strm.zfree = Z_NULL;
  26.     strm.opaque = Z_NULL;
  28.     ret = deflateInit(&strm, level);
  29.     if (ret != Z_OK)
  30.         return ret;
  31.  
  32.     /* comprime ate o fim do arquivo */
  33.     do {
  34.         strm.avail_in = fread(in, 1, CHUNK, source);
  35.         if (ferror(source)) {
  36.             (void)deflateEnd(&strm);
  37.             return Z_ERRNO;
  38.         }
  39.         flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
  40.         strm.next_in = in;
  41.         /* executa deflate() na entrada enquanto o buffer de saida nao estiver
  42.            cheio, termina compressao se 'source' tiver sido lido completamente */
  43.         do {
  44.             strm.avail_out = CHUNK;
  45.             strm.next_out = out;
  46.             ret = deflate(&strm, flush);
  47.             assert(ret != Z_STREAM_ERROR);
  48.             have = CHUNK - strm.avail_out;
  49.             if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
  50.                 (void)deflateEnd(&strm);
  51.                 return Z_ERRNO;
  52.             }
  53.         } while (strm.avail_out == 0);
  54.         assert(strm.avail_in == 0);     /* toda a entrada sera usada*/
  55.         /* done quando o ultimo dado do arquivo for processado */
  56.     } while (flush != Z_FINISH);
  57.     assert(ret == Z_STREAM_END);        /* a stream estara completa*/
  58.     /* limpa buffer e retorna */
  59.     (void)deflateEnd(&strm);
  60.     return Z_OK;
  61. }
  62.  
  63. /* Descomprime de 'source' para 'dest' até o fim do buffer de arquivo
  64.    inf() retorna Z_OK caso tudo ocorra bem, Z_MEM_ERROR se a memória nao pode
  65.    ser alocada, Z_DATA_ERROR se o arquivo source contem erros(invalido ou
  66.    imcompleto), Z_VERSION_ERROR se a versao do cabeçalho zlib.h e a versao
  67.    da biblioteca estatica nao batem, ou Z_ERRNO se há um erro ao ler ou escrever
  68.    os arquivos */
  69.  
  70. int descomprime(FILE *source, FILE *dest)
  71. {
  72.     int ret;
  73.     unsigned have;
  74.     z_stream strm;
  75.     unsigned char in[CHUNK];
  76.     unsigned char out[CHUNK];
  77.  
  78.     strm.zalloc = Z_NULL;
  79.     strm.zfree = Z_NULL;
  80.     strm.opaque = Z_NULL;
  81.     strm.avail_in = 0;
  82.     strm.next_in = Z_NULL;
  84.     ret = inflateInit(&strm);
  85.     if (ret != Z_OK)
  86.         return ret;
  87.  
  88.     do {
  89.         strm.avail_in = fread(in, 1, CHUNK, source);
  90.         if (ferror(source)) {
  91.             (void)inflateEnd(&strm);
  92.             return Z_ERRNO;
  93.         }
  94.         if (strm.avail_in == 0)
  95.             break;
  96.         strm.next_in = in;
  97.         do {
  98.             strm.avail_out = CHUNK;
  99.             strm.next_out = out;
  100.             ret = inflate(&strm, Z_NO_FLUSH);
  101.             assert(ret != Z_STREAM_ERROR);
  102.             switch (ret) {
  103.             case Z_NEED_DICT:
  104.                 ret = Z_DATA_ERROR;
  105.             case Z_DATA_ERROR:
  106.             case Z_MEM_ERROR:
  107.                 (void)inflateEnd(&strm);
  108.                 return ret;
  109.             }
  110.             have = CHUNK - strm.avail_out;
  111.             if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
  112.                 (void)inflateEnd(&strm);
  113.                 return Z_ERRNO;
  114.             }
  115.         } while (strm.avail_out == 0);
  116.         /* done quando inflate() diz q chegou o fim do arquivo */
  117.     } while (ret != Z_STREAM_END);
  118.     /* limpa buffer e retorna*/
  119.     (void)inflateEnd(&strm);
  120.     return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
  121. }