cpan/IO-Compress/lib/IO/Uncompress/Adapter/Inflate.pm

   1 package IO::Uncompress::Adapter::Inflate;
   2
   3 use strict;
   4 use warnings;
   5 use bytes;
   6
   7 use IO::Compress::Base::Common  2.044 qw(:Status);
   8 use Compress::Raw::Zlib  2.044 qw(Z_OK Z_BUF_ERROR Z_STREAM_END Z_FINISH MAX_WBITS);
   9
  10 our ($VERSION);
  11 $VERSION = '2.044';
  12
  13
  14
  15 sub mkUncompObject
  16 {
  17     my $crc32   = shift || 1;
  18     my $adler32 = shift || 1;
  19     my $scan    = shift || 0;
  20
  21     my $inflate ;
  22     my $status ;
  23
  24     if ($scan)
  25     {
  26         ($inflate, $status) = new Compress::Raw::Zlib::InflateScan
  27                                     #LimitOutput  => 1,
  28                                     CRC32        => $crc32,
  29                                     ADLER32      => $adler32,
  30                                     WindowBits   => - MAX_WBITS ;
  31     }
  32     else
  33     {
  34         ($inflate, $status) = new Compress::Raw::Zlib::Inflate
  35                                     AppendOutput => 1,
  36                                     LimitOutput  => 1,
  37                                     CRC32        => $crc32,
  38                                     ADLER32      => $adler32,
  39                                     WindowBits   => - MAX_WBITS ;
  40     }
  41
  42     return (undef, "Could not create Inflation object: $status", $status)
  43         if $status != Z_OK ;
  44
  45     return bless {'Inf'        => $inflate,
  46                   'CompSize'   => 0,
  47                   'UnCompSize' => 0,
  48                   'Error'      => '',
  49                   'ConsumesInput' => 1,
  50                  } ;
  51
  52 }
  53
  54 sub uncompr
  55 {
  56     my $self = shift ;
  57     my $from = shift ;
  58     my $to   = shift ;
  59     my $eof  = shift ;
  60
  61     my $inf   = $self->{Inf};
  62
  63     my $status = $inf->inflate($from, $to, $eof);
  64     $self->{ErrorNo} = $status;
  65
  66     if ($status != Z_OK && $status != Z_STREAM_END && $status != Z_BUF_ERROR)
  67     {
  68         $self->{Error} = "Inflation Error: $status";
  69         return STATUS_ERROR;
  70     }
  71
  72     return STATUS_OK        if $status == Z_BUF_ERROR ; # ???
  73     return STATUS_OK        if $status == Z_OK ;
  74     return STATUS_ENDSTREAM if $status == Z_STREAM_END ;
  75     return STATUS_ERROR ;
  76 }
  77
  78 sub reset
  79 {
  80     my $self = shift ;
  81     $self->{Inf}->inflateReset();
  82
  83     return STATUS_OK ;
  84 }
  85
  86 #sub count
  87 #{
  88 #    my $self = shift ;
  89 #    $self->{Inf}->inflateCount();
  90 #}
  91
  92 sub crc32
  93 {
  94     my $self = shift ;
  95     $self->{Inf}->crc32();
  96 }
  97
  98 sub compressedBytes
  99 {
 100     my $self = shift ;
 101     $self->{Inf}->compressedBytes();
 102 }
 103
 104 sub uncompressedBytes
 105 {
 106     my $self = shift ;
 107     $self->{Inf}->uncompressedBytes();
 108 }
 109
 110 sub adler32
 111 {
 112     my $self = shift ;
 113     $self->{Inf}->adler32();
 114 }
 115
 116 sub sync
 117 {
 118     my $self = shift ;
 119     ( $self->{Inf}->inflateSync(@_) == Z_OK)
 120             ? STATUS_OK
 121             : STATUS_ERROR ;
 122 }
 123
 124
 125 sub getLastBlockOffset
 126 {
 127     my $self = shift ;
 128     $self->{Inf}->getLastBlockOffset();
 129 }
 130
 131 sub getEndOffset
 132 {
 133     my $self = shift ;
 134     $self->{Inf}->getEndOffset();
 135 }
 136
 137 sub resetLastBlockByte
 138 {
 139     my $self = shift ;
 140     $self->{Inf}->resetLastBlockByte(@_);
 141 }
 142
 143 sub createDeflateStream
 144 {
 145     my $self = shift ;
 146     my $deflate = $self->{Inf}->createDeflateStream(@_);
 147     return bless {'Def'        => $deflate,
 148                   'CompSize'   => 0,
 149                   'UnCompSize' => 0,
 150                   'Error'      => '',
 151                  }, 'IO::Compress::Adapter::Deflate';
 152 }
 153
 154 1;
 155
 156
 157 __END__
 158