1Compress::Bzip2(3)    User Contributed Perl Documentation   Compress::Bzip2(3)
2
3
4

NAME

6       Compress::Bzip2 - Interface to Bzip2 compression library
7

SYNOPSIS

9           use Compress::Bzip2 qw(:all :constant :utilities :gzip);
10
11           ($bz, $status) = bzdeflateInit( [PARAMS] );
12           ($out, $status) = $bz->bzdeflate($buffer) ; # compress
13
14           ($bz, $status) = bzinflateInit( [PARAMS] );
15           ($out, $status) = $bz->bzinflate($buffer);  # uncompress
16
17           ($out, $status) = $bz->bzflush() ;
18           ($out, $status) = $bz->bzclose() ;
19
20           $dest = memBzip($source);
21               alias compress
22           $dest = memBunzip($source);
23               alias decompress
24
25           $bz = Compress::Bzip2->new( [PARAMS] );
26
27           $bz = bzopen($filename or filehandle, $mode);
28               alternate, with $bz created by new():
29           $bz->bzopen($filename or filehandle, $mode);
30
31           $bytesread = $bz->bzread($buffer [,$size]) ;
32           $bytesread = $bz->bzreadline($line);
33           $byteswritten = $bz->bzwrite($buffer [,$limit]);
34           $errstring = $bz->bzerror();
35           $status = $bz->bzeof();
36           $status = $bz->bzflush();
37           $status = $bz->bzclose() ;
38
39           $status = $bz->bzsetparams( $param => $setting );
40
41           $bz->total_in() ;
42           $bz->total_out() ;
43
44           $verstring = $bz->bzversion();
45
46           $Compress::Bzip2::bzerrno
47

DESCRIPTION

49       The Compress::Bzip2 module provides a Perl interface to the bzip2
50       compression library (see "AUTHOR" for details about where to get
51       Bzip2). A relevant subset of the functionality provided by bzip2 is
52       available in Compress::Bzip2.
53
54       All string parameters can either be a scalar or a scalar reference.
55
56       The module can be split into two general areas of functionality, namely
57       in-memory compression/decompression and read/write access to bzip2
58       files. Each of these areas will be discussed separately below.
59
60       NOTE
61
62       Compress::Bzip2 is just a simple bzip2 binding, comparable to the old
63       Compress::Zlib library. It is not well integrated into PerlIO, use the
64       preferred IO::Compress::Bzip2 instead.
65

FILE READ/WRITE INTERFACE

67       A number of functions are supplied in bzlib for reading and writing
68       bzip2 files. Unfortunately, most of them are not suitable.  So, this
69       module provides another interface, built over top of the low level
70       bzlib methods.
71
72   $bz = bzopen(filename or filehandle, mode)
73       This function returns an object which is used to access the other bzip2
74       methods.
75
76       The mode parameter is used to specify both whether the file is opened
77       for reading or writing, with "r" or "w" respectively.
78
79       If a reference to an open filehandle is passed in place of the
80       filename, it better be positioned to the start of a
81       compression/decompression sequence.
82
83       WARNING: With Perl 5.6 you cannot use a filehandle because of SEGV in
84       destruction with bzclose or an implicit close.
85
86   $bz = Compress::Bzip2->new( [PARAMS] )
87       Create a Compress::Bzip2 object.  Optionally, provide
88       compression/decompression parameters as a keyword => setting list.  See
89       bzsetparams() for a description of the parameters.
90
91   $bz->bzopen(filename or filehandle, mode)
92       This is bzopen, but it uses an object previously created by the new
93       method.  Other than that, it is identical to the above bzopen.
94
95   $bytesread = $bz->bzread($buffer [, $size]) ;
96       Reads $size bytes from the compressed file into $buffer. If $size is
97       not specified, it will default to 4096. If the scalar $buffer is not
98       large enough, it will be extended automatically.
99
100       Returns the number of bytes actually read. On EOF it returns 0 and in
101       the case of an error, -1.
102
103   $bytesread = $bz->bzreadline($line) ;
104       Reads the next line from the compressed file into $line.
105
106       Returns the number of bytes actually read. On EOF it returns 0 and in
107       the case of an error, -1.
108
109       It IS legal to intermix calls to bzread and bzreadline.
110
111       At this time bzreadline ignores the variable $/
112       ($INPUT_RECORD_SEPARATOR or $RS when "English" is in use). The end of a
113       line is denoted by the C character '\n'.
114
115   $byteswritten = $bz->bzwrite($buffer [, $limit]) ;
116       Writes the contents of $buffer to the compressed file. Returns the
117       number of bytes actually written, or 0 on error.
118
119       If $limit is given and non-zero, then only that many bytes from $buffer
120       will be written.
121
122   $status = $bz->bzflush($flush) ;
123       Flushes all pending output to the compressed file.  Works identically
124       to the zlib function it interfaces to. Note that the use of bzflush can
125       degrade compression.
126
127       Returns "BZ_OK" if $flush is "BZ_FINISH" and all output could be
128       flushed. Otherwise the bzlib error code is returned.
129
130       Refer to the bzlib documentation for the valid values of $flush.
131
132   $status = $bz->bzeof() ;
133       Returns 1 if the end of file has been detected while reading the input
134       file, otherwise returns 0.
135
136   $bz->bzclose
137       Closes the compressed file. Any pending data is flushed to the file
138       before it is closed.
139
140   $bz->bzsetparams( [PARAMS] );
141       Change settings for the deflate stream $bz.
142
143       The list of the valid options is shown below. Options not specified
144       will remain unchanged.
145
146       -verbosity
147            Defines the verbosity level. Valid values are 0 through 4,
148
149            The default is "-verbosity => 0".
150
151       -blockSize100k
152            For bzip object opened for stream deflation or write.
153
154            Defines the buffering factor of compression method.  The algorithm
155            buffers all data until the buffer is full, then it flushes all the
156            data out.  Use -blockSize100k to specify the size of the buffer.
157
158            Valid settings are 1 through 9, representing a blocking in
159            multiples of 100k.
160
161            Note that each such block has an overhead of leading and trailing
162            synchronization bytes.  bzip2 recovery uses this information to
163            pull useable data out of a corrupted file.
164
165            A streaming application would probably want to set the blocking
166            low.
167
168       -workFactor
169            For bzip object opened for stream deflation or write.
170
171            The workFactor setting tells the deflation algorithm how much work
172            to invest to compensate for repetitive data.
173
174            workFactor may be a number from 0 to 250 inclusive.  The default
175            setting is 30.
176
177            See the bzip documentation for more information.
178
179       -small
180            For bzip object opened for stream inflation or read.
181
182            small may be 0 or 1.  Set "small" to one to use a slower, less
183            memory intensive algorithm.
184
185   $bz->bzerror
186       Returns the bzlib error message or number for the last operation
187       associated with $bz. The return value will be the bzlib error number
188       when used in a numeric context and the bzlib error message when used in
189       a string context. The bzlib error number constants, shown below, are
190       available for use.
191
192         BZ_CONFIG_ERROR
193         BZ_DATA_ERROR
194         BZ_DATA_ERROR_MAGIC
195         BZ_FINISH
196         BZ_FINISH_OK
197         BZ_FLUSH
198         BZ_FLUSH_OK
199         BZ_IO_ERROR
200         BZ_MAX_UNUSED
201         BZ_MEM_ERROR
202         BZ_OK
203         BZ_OUTBUFF_FULL
204         BZ_PARAM_ERROR
205         BZ_RUN
206         BZ_RUN_OK
207         BZ_SEQUENCE_ERROR
208         BZ_STREAM_END
209         BZ_UNEXPECTED_EOF
210
211   $bz->bzclearerr
212   $bzerrno
213       The $bzerrno scalar holds the error code associated with the most
214       recent bzip2 routine. Note that unlike bzerror(), the error is not
215       associated with a particular file.
216
217       As with bzerror() it returns an error number in numeric context and an
218       error message in string context. Unlike bzerror() though, the error
219       message will correspond to the bzlib message when the error is
220       associated with bzlib itself, or the UNIX error message when it is not
221       (i.e. bzlib returned "Z_ERRORNO").
222
223       As there is an overlap between the error numbers used by bzlib and
224       UNIX, $bzerrno should only be used to check for the presence of an
225       error in numeric context. Use bzerror() to check for specific bzlib
226       errors. The bzcat example below shows how the variable can be used
227       safely.
228
229   $bz->prefix
230       Returns the additional 5 byte header which is prepended to the bzip2
231       header  starting with "BZh" when using memBzip/compress.
232

Compress::Bzip2 Utilities

234       Options: -d -c -z -f -v -k -s -1..9
235
236   bzip2( [OPTS], filename)
237   bunzip2(filename)
238   bzcat(filenames...)
239   bzlibversion()
240   bzinflateInit( opts... )

Internal Utilties

242   bz_seterror(errno, msg) =head2 $bz->is_read() =head2 $bz->is_stream()
243       =head2 $bz->is_write() =head2 $bz->total_in() =head2 $bz->total_out()
244       =head2 version()

Compress::Bzip2 1.03 COMPATIBILITY

246       While the 2.x thread forked off of 1.00, another line of development
247       came to a head at 1.03.  The 1.03 version worked with bzlib 1.0.2, had
248       improvements to the error handling, single buffer inflate/deflate, a
249       streaming interface to inflate/deflate, and a cpan style test suite.
250
251   $dest = compress( $string, [$level] )
252       Alias to memBzip, this compresses string, using the optional
253       compression level, 1 through 9, the default being 6.  Returns a string
254       containing the compressed data.
255
256       On error undef is returned.
257
258   $dest = decompress($string, [$level])
259       Alias to memBunzip, this decompresses the data in string, returning a
260       string containing the decompressed data.
261
262       On error undef is returned.
263
264   uncompress($string, [$level])
265       Another alias to memBunzip
266
267   $stream = compress_init( [PARAMS] )
268       Alias to bzdeflateInit.  In addition to the named parameters documented
269       for bzdeflateInit, the following are accepted:
270
271          -level, alias to -blockSize100k
272          -buffer, to set the buffer size.
273
274       The -buffer option is ignored.  The intermediate buffer size is not
275       changeable.
276
277   $stream = decompress_init( [PARAMS] )
278       Alias to bzinflateInit.  See bzinflateInit for a description of the
279       parameters.  The option "-buffer" is accepted, but ignored.
280
281   $output = $stream->add( $string )
282       Add data to be compressed/decompressed.  Returns whatever output is
283       available (possibly none, if it's still buffering it), or undef on
284       error.
285
286   $output = $stream->finish( [$string] )
287       Finish the operation; takes an optional final data string.  Whatever is
288       returned completes the output; returns undef on error.
289
290   $stream->error
291       Like the function, but applies to the current object only.  Note that
292       errors in a stream object are also returned by the function.
293
294   $stream->input_size
295       Alias to total_in.  Total bytes passed to the stream.
296
297   $stream->output_size
298       Alias to total_out.  Total bytes received from the stream.
299

GZIP COMPATIBILITY INTERFACE

301       Except for the exact state and error numbers, this package presents an
302       interface very much like that given by the Compress::Zlib package.
303       Mostly, if you take the method name, state or error number from
304       Compress::Zlib and replace the "g" with a "b", your code should work.
305
306       To make the interoperability even easier, all the Compress::Zlib method
307       names have been used as aliases or cover functions for the bzip2
308       methods.
309
310       Therefore, most code that uses Compress::Zlib should be able to use
311       this package, with a one line change.
312
313       Simply change
314
315          $gz = Compress::Zlib::gzopen( "filename", "w" );
316
317       to
318
319          $gz = Compress::Bzip2::gzopen( "filename", "w" );
320
321       Some of the Compress::Zlib aliases don't return anything useful, like
322       crc32 or adler32, cause bzip2 doesn't do that sort of thing.
323
324    $gz = gzopen( $filename, $mode )
325       Alias for bzopen.
326
327    $gz->gzread( $buffer, [ $length ] )
328       Alias for bzread.
329
330    $gz->gzreadline( $buffer )
331       Alias for bzreadline.
332
333    $gz->gzwrite( $buffer )
334       Alias for bzwrite.
335
336    $gz->gzflush( [$flushtype] )
337       Alias for bzflush, with return code translation.
338
339    $gz->gzclose( )
340       Alias for bzclose.
341
342    $gz->gzeof( )
343       Alias for bzeof.
344
345    $gz->gzerror( )
346       Alias for bzerror.
347
348    $gz->gzsetparams( $level, $strategy )
349       This is a no-op.
350
351    $d = deflateInit( [OPTS] )
352       Alias for bzdeflateInit, with return code translation.
353
354       All OPTS are ignored.
355
356    $d->deflate( $buffer )
357       Alias for bzdeflate, with return code translation.
358
359    $d->deflateParams( [OPTS] )
360       This is a no-op.
361
362    $d->flush( [$flushtype] )
363       Cover function for bzflush or bzclose, depending on $flushtype.
364
365       See the Compress::Zlib documentation for more information.
366
367    $d->dict_adler( )
368       This is a no-op.
369
370    $d->msg( )
371       This is a no-op.
372
373    $d = inflateInit( [OPTS] )
374       Alias for bzinflateInit, with return code translation.
375
376       All OPTS are ignored.
377
378    $d->inflate( )
379       Alias for bzinflate, with return code translation.
380
381    $d->inflateSync( )
382       This is a no-op.
383
384    $d->adler32( $crc )
385       This is a no-op.
386
387    $d->crc32( $crc )
388       This is a no-op.
389
390    $buffer = memGzip( $buffer )
391       Alias for memBzip.
392
393    $buffer = memGunzip( $buffer )
394       Alias for memBunzip.
395

IN-MEMORY COMPRESS/UNCOMPRESS

397       Two high-level functions are provided by bzlib to perform in-memory
398       compression. They are memBzip and memBunzip. Two Perl subs are provided
399       which provide similar functionality.
400
401   $compressed = memBzip($buffer);
402       Compresses $buffer. If successful it returns the compressed data.
403       Otherwise it returns undef.
404
405       The buffer parameter can either be a scalar or a scalar reference.
406
407       Essentially, an in-memory bzip file is created. It creates a minimal
408       bzip header, which adds 5 bytes before the bzip2 specific BZh header.
409
410   $uncompressed = memBunzip($buffer);
411       Uncompresses $buffer. If successful it returns the uncompressed data.
412       Otherwise it returns undef.
413
414       The source buffer can either be a scalar or a scalar reference.
415
416       The buffer parameter can either be a scalar or a scalar reference. The
417       contents of the buffer parameter are destroyed after calling this
418       function.
419

STREAM DEFLATE (= COMPRESS)

421       The Perl interface will always consume the complete input buffer before
422       returning. Also the output buffer returned will be automatically grown
423       to fit the amount of output available.
424
425       Here is a definition of the interface available:
426
427   ($d, $status) = bzdeflateInit( [PARAMS] )
428       Initialises a deflation stream.
429
430       If successful, it will return the initialised deflation stream, $d and
431       $status of "BZ_OK" in a list context. In scalar context it returns the
432       deflation stream, $d, only.
433
434       If not successful, the returned deflation stream ($d) will be undef and
435       $status will hold the exact bzip2 error code.
436
437       The function optionally takes a number of named options specified as
438       "-Name=>value" pairs. This allows individual options to be tailored
439       without having to specify them all in the parameter list.
440
441       Here is a list of the valid options:
442
443       -verbosity
444            Defines the verbosity level. Valid values are 0 through 4,
445
446            The default is "-verbosity => 0".
447
448       -blockSize100k
449            Defines the buffering factor of compression method.  The algorithm
450            buffers all data until the buffer is full, then it flushes all the
451            data out.  Use -blockSize100k to specify the size of the buffer.
452
453            Valid settings are 1 through 9, representing a blocking in
454            multiples of 100k.
455
456            Note that each such block has an overhead of leading and trailing
457            synchronization bytes.  bzip2 recovery uses this information to
458            pull useable data out of a corrupted file.
459
460            A streaming application would probably want to set the blocking
461            low.
462
463       -workFactor
464            The workFactor setting tells the deflation algorithm how much work
465            to invest to compensate for repetitive data.
466
467            workFactor may be a number from 0 to 250 inclusive.  The default
468            setting is 30.
469
470            See the bzip documentation for more information.
471
472       Here is an example of using the deflateInit optional parameter list to
473       override the default buffer size and compression level. All other
474       options will take their default values.
475
476           bzdeflateInit( -blockSize100k => 1, -verbosity => 1 );
477
478   ($out, $status) = $d->bzdeflate($buffer)
479       Deflates the contents of $buffer. The buffer can either be a scalar or
480       a scalar reference.  When finished, $buffer will be completely
481       processed (assuming there were no errors). If the deflation was
482       successful it returns deflated output, $out, and a status value,
483       $status, of "Z_OK".
484
485       On error, $out will be undef and $status will contain the zlib error
486       code.
487
488       In a scalar context bzdeflate will return $out only.
489
490       As with the internal buffering of the deflate function in bzip2, it is
491       not necessarily the case that any output will be produced by this
492       method. So don't rely on the fact that $out is empty for an error test.
493       In fact, given the size of bzdeflates internal buffer, with most files
494       it's likely you won't see any output at all until flush or close.
495
496   ($out, $status) = $d->bzflush([flush_type])
497       Typically used to finish the deflation. Any pending output will be
498       returned via $out.  $status will have a value "BZ_OK" if successful.
499
500       In a scalar context bzflush will return $out only.
501
502       Note that flushing can seriously degrade the compression ratio, so it
503       should only be used to terminate a decompression (using "BZ_FLUSH") or
504       when you want to create a full flush point (using "BZ_FINISH").
505
506       The allowable values for "flush_type" are "BZ_FLUSH" and "BZ_FINISH".
507
508       For a handle opened for "w" (bzwrite), the default is "BZ_FLUSH".  For
509       a stream, the default for "flush_type" is "BZ_FINISH" (which is
510       essentially a close and reopen).
511
512       It is strongly recommended that you only set the "flush_type" parameter
513       if you fully understand the implications of what it does. See the
514       "bzip2" documentation for details.
515
516   Example
517       Here is a trivial example of using bzdeflate. It simply reads standard
518       input, deflates it and writes it to standard output.
519
520           use strict ;
521           use warnings ;
522
523           use Compress::Bzip2 ;
524
525           binmode STDIN;
526           binmode STDOUT;
527           my $x = bzdeflateInit()
528              or die "Cannot create a deflation stream\n" ;
529
530           my ($output, $status) ;
531           while (<>)
532           {
533               ($output, $status) = $x->bzdeflate($_) ;
534
535               $status == BZ_OK
536                   or die "deflation failed\n" ;
537
538               print $output ;
539           }
540
541           ($output, $status) = $x->bzclose() ;
542
543           $status == BZ_OK
544               or die "deflation failed\n" ;
545
546           print $output ;
547

STREAM INFLATE

549       Here is a definition of the interface:
550
551   ($i, $status) = inflateInit()
552       Initialises an inflation stream.
553
554       In a list context it returns the inflation stream, $i, and the zlib
555       status code ($status). In a scalar context it returns the inflation
556       stream only.
557
558       If successful, $i will hold the inflation stream and $status will be
559       "BZ_OK".
560
561       If not successful, $i will be undef and $status will hold the bzlib.h
562       error code.
563
564       The function optionally takes a number of named options specified as
565       "-Name=>value" pairs. This allows individual options to be tailored
566       without having to specify them all in the parameter list.
567
568       For backward compatibility, it is also possible to pass the parameters
569       as a reference to a hash containing the name=>value pairs.
570
571       The function takes one optional parameter, a reference to a hash.  The
572       contents of the hash allow the deflation interface to be tailored.
573
574       Here is a list of the valid options:
575
576       -small
577            small may be 0 or 1.  Set "small" to one to use a slower, less
578            memory intensive algorithm.
579
580       -verbosity
581            Defines the verbosity level. Valid values are 0 through 4,
582
583            The default is "-verbosity => 0".
584
585       Here is an example of using the bzinflateInit optional parameter.
586
587           bzinflateInit( -small => 1, -verbosity => 1 );
588
589   ($out, $status) = $i->bzinflate($buffer)
590       Inflates the complete contents of $buffer. The buffer can either be a
591       scalar or a scalar reference.
592
593       Returns "BZ_OK" if successful and "BZ_STREAM_END" if the end of the
594       compressed data has been successfully reached.  If not successful, $out
595       will be undef and $status will hold the bzlib error code.
596
597       The $buffer parameter is modified by "bzinflate". On completion it will
598       contain what remains of the input buffer after inflation. This means
599       that $buffer will be an empty string when the return status is "BZ_OK".
600       When the return status is "BZ_STREAM_END" the $buffer parameter will
601       contains what (if anything) was stored in the input buffer after the
602       deflated data stream.
603
604       This feature is useful when processing a file format that encapsulates
605       a compressed data stream.
606
607   Example
608       Here is an example of using bzinflate.
609
610           use strict ;
611           use warnings ;
612
613           use Compress::Bzip2;
614
615           my $x = bzinflateInit()
616              or die "Cannot create a inflation stream\n" ;
617
618           my $input = '' ;
619           binmode STDIN;
620           binmode STDOUT;
621
622           my ($output, $status) ;
623           while (read(STDIN, $input, 4096))
624           {
625               ($output, $status) = $x->bzinflate(\$input) ;
626
627               print $output
628                   if $status == BZ_OK or $status == BZ_STREAM_END ;
629
630               last if $status != BZ_OK ;
631           }
632
633           die "inflation failed\n"
634               unless $status == BZ_STREAM_END ;
635

EXAMPLES

637       Here are some example scripts of using the interface.
638
639   A bzcat function
640         use strict ;
641         use warnings ;
642
643         use Compress::Bzip2 ;
644
645         die "Usage: bzcat file...\n" unless @ARGV ;
646
647         my $file ;
648
649         foreach $file (@ARGV) {
650           my $buffer ;
651
652           my $bz = bzopen($file, "rb")
653              or die "Cannot open $file: $bzerrno\n" ;
654
655           print $buffer while $bz->bzread($buffer) > 0 ;
656
657           die "Error reading from $file: $bzerrno" . ($bzerrno+0) . "\n"
658              if $bzerrno != BZ_STREAM_END ;
659
660           $bz->bzclose() ;
661         }
662
663   A grep using bzreadline
664         use strict ;
665         use warnings ;
666
667         use Compress::Bzip2 ;
668
669         die "Usage: bzgrep pattern file...\n" unless @ARGV >= 2;
670
671         my $pattern = shift ;
672
673         my $file ;
674
675         foreach $file (@ARGV) {
676           my $bz = bzopen($file, "rb")
677              or die "Cannot open $file: $bzerrno\n" ;
678
679           while ($bz->bzreadline($_) > 0) {
680             print if /$pattern/ ;
681           }
682
683           die "Error reading from $file: $bzerrno\n"
684             if $bzerrno != Z_STREAM_END ;
685
686           $bz->bzclose() ;
687         }
688
689   Streaming Compression
690       This script, bzstream, does the opposite of the bzcat script above. It
691       reads from standard input and writes a bzip file to standard output.
692
693         use strict ;
694         use warnings ;
695
696         use Compress::Bzip2 ;
697
698         binmode STDOUT;       # bzopen only sets it on the fd
699
700         my $bz = bzopen(\*STDOUT, "wb")
701            or die "Cannot open stdout: $bzerrno\n" ;
702
703         while (<>) {
704           $bz->bzwrite($_) or die "error writing: $bzerrno\n" ;
705         }
706
707         $bz->bzclose ;
708

EXPORT

710       Use the tags :all, :utilities, :constants, :bzip1 and :gzip.
711
712   Export tag :all
713       This exports all the exportable methods.
714
715   Export tag :constants
716       This exports only the BZ_* constants.
717
718   Export tag :bzip1
719       This exports the Compress::Bzip2 1.x functions, for compatibility.
720
721          compress
722          decompress
723          compress_init
724          decompress_init
725          version
726
727       These are actually aliases to memBzip and memBunzip.
728
729   Export tag :utilities
730       This gives an interface to the bzip2 methods.
731
732           bzopen
733           bzinflateInit
734           bzdeflateInit
735           memBzip
736           memBunzip
737           bzip2
738           bunzip2
739           bzcat
740           bzlibversion
741           $bzerrno
742
743   Export tag :gzip
744       This gives compatibility with Compress::Zlib.
745
746           gzopen
747           gzinflateInit
748           gzdeflateInit
749           memGzip
750           memGunzip
751           $gzerrno
752

Exportable constants

754       All the bzlib constants are automatically imported when you make use of
755       Compress::Bzip2.
756
757         BZ_CONFIG_ERROR
758         BZ_DATA_ERROR
759         BZ_DATA_ERROR_MAGIC
760         BZ_FINISH
761         BZ_FINISH_OK
762         BZ_FLUSH
763         BZ_FLUSH_OK
764         BZ_IO_ERROR
765         BZ_MAX_UNUSED
766         BZ_MEM_ERROR
767         BZ_OK
768         BZ_OUTBUFF_FULL
769         BZ_PARAM_ERROR
770         BZ_RUN
771         BZ_RUN_OK
772         BZ_SEQUENCE_ERROR
773         BZ_STREAM_END
774         BZ_UNEXPECTED_EOF
775

SEE ALSO

777       The documentation for zlib, bzip2 and Compress::Zlib.
778

AUTHOR

780       Rob Janes, <arjay at cpan.org>
781
783       Copyright (C) 2005 by Rob Janes
784
785       This library is free software; you can redistribute it and/or modify it
786       under the same terms as Perl itself, either Perl version 5.8.3 or, at
787       your option, any later version of Perl 5 you may have available.
788

AUTHOR

790       The Compress::Bzip2 module was originally written by Gawdi Azem
791       azemgi@rupert.informatik.uni-stuttgart.de.
792
793       The first Compress::Bzip2 module was written by Gawdi Azem
794       azemgi@rupert.informatik.uni-stuttgart.de.  It provided an interface to
795       the in memory inflate and deflate routines.
796
797       Compress::Bzip2 was subsequently passed on to Marco Carnut
798       kiko@tempest.com.br who shepherded it through to version 1.03, a set of
799       changes which included upgrades to handle bzlib 1.0.2, and improvements
800       to the in memory inflate and deflate routines.  The streaming interface
801       and error information were added by David Robins
802       dbrobins@davidrobins.net.
803
804       Version 2 of Compress::Bzip2 is due to Rob Janes, of arjay@cpan.org.
805       This release is intended to give an interface close to that of
806       Compress::Zlib.  It's development forks from 1.00, not 1.03, so the
807       streaming interface is not the same as that in 1.03, although
808       apparently compatible as it passes the 1.03 test suite.
809
810       Minor subsequent fixes and releases were done by Reini Urban,
811       rurban@cpan.org.
812

MODIFICATION HISTORY

814       See the Changes file.
815
816       2.00 Second public release of Compress::Bzip2.
817
818
819
820perl v5.36.0                      2022-07-22                Compress::Bzip2(3)
Impressum