------------------------------------------------------------------------------

-- ZLib for Ada thick binding. --

-- --

-- Copyright (C) 2002-2004 Dmitriy Anisimkov --

-- --

-- This library is free software; you can redistribute it and/or modify --

-- it under the terms of the GNU General Public License as published by --

-- the Free Software Foundation; either version 2 of the License, or (at --

-- your option) any later version. --

-- --

-- This library is distributed in the hope that it will be useful, but --

-- WITHOUT ANY WARRANTY; without even the implied warranty of --

-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --

-- General Public License for more details. --

-- --

-- You should have received a copy of the GNU General Public License --

-- along with this library; if not, write to the Free Software Foundation, --

-- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. --

-- --

-- As a special exception, if other files instantiate generics from this --

-- unit, or you link this unit with other files to produce an executable, --

-- this unit does not by itself cause the resulting executable to be --

-- covered by the GNU General Public License. This exception does not --

-- however invalidate any other reasons why the executable file might be --

-- covered by the GNU Public License. --

------------------------------------------------------------------------------

-- $Id: zlib.ads,v 1.26 2004/09/06 06:53:19 vagul Exp $

with Ada.Streams;

with Interfaces;

package ZLib is

ZLib_Error : exception;

Status_Error : exception;

type Compression_Level is new Integer range -1 .. 9;

type Flush_Mode is private;

type Compression_Method is private;

type Window_Bits_Type is new Integer range 8 .. 15;

type Memory_Level_Type is new Integer range 1 .. 9;

type Unsigned_32 is new Interfaces.Unsigned_32;

type Strategy_Type is private;

type Header_Type is (None, Auto, Default, GZip);

-- Header type usage have a some limitation for inflate.

-- See comment for Inflate_Init.

subtype Count is Ada.Streams.Stream_Element_Count;

Default_Memory_Level : constant Memory_Level_Type := 8;

Default_Window_Bits : constant Window_Bits_Type := 15;

----------------------------------

-- Compression method constants --

----------------------------------

Deflated : constant Compression_Method;

-- Only one method allowed in this ZLib version

---------------------------------

-- Compression level constants --

---------------------------------

No_Compression : constant Compression_Level := 0;

Best_Speed : constant Compression_Level := 1;

Best_Compression : constant Compression_Level := 9;

Default_Compression : constant Compression_Level := -1;

--------------------------

-- Flush mode constants --

--------------------------

No_Flush : constant Flush_Mode;

-- Regular way for compression, no flush

Partial_Flush : constant Flush_Mode;

-- Will be removed, use Z_SYNC_FLUSH instead

Sync_Flush : constant Flush_Mode;

-- All pending output is flushed to the output buffer and the output

-- is aligned on a byte boundary, so that the decompressor can get all

-- input data available so far. (In particular avail_in is zero after the

-- call if enough output space has been provided before the call.)

-- Flushing may degrade compression for some compression algorithms and so

-- it should be used only when necessary.

Block_Flush : constant Flush_Mode;

-- Z_BLOCK requests that inflate() stop

-- if and when it get to the next deflate block boundary. When decoding the

-- zlib or gzip format, this will cause inflate() to return immediately

-- after the header and before the first block. When doing a raw inflate,

-- inflate() will go ahead and process the first block, and will return

-- when it gets to the end of that block, or when it runs out of data.

Full_Flush : constant Flush_Mode;

-- All output is flushed as with SYNC_FLUSH, and the compression state

-- is reset so that decompression can restart from this point if previous

-- compressed data has been damaged or if random access is desired. Using

-- Full_Flush too often can seriously degrade the compression.

Finish : constant Flush_Mode;

-- Just for tell the compressor that input data is complete.

------------------------------------

-- Compression strategy constants --

------------------------------------

-- RLE stategy could be used only in version 1.2.0 and later.

Filtered : constant Strategy_Type;

Huffman_Only : constant Strategy_Type;

RLE : constant Strategy_Type;

Default_Strategy : constant Strategy_Type;

Default_Buffer_Size : constant := 4096;

type Filter_Type is tagged limited private;

-- The filter is for compression and for decompression.

-- The usage of the type is depend of its initialization.

function Version return String;

pragma Inline (Version);

-- Return string representation of the ZLib version.

procedure Deflate_Init

(Filter : in out Filter_Type;

Level : in Compression_Level := Default_Compression;

Strategy : in Strategy_Type := Default_Strategy;

Method : in Compression_Method := Deflated;

Window_Bits : in Window_Bits_Type := Default_Window_Bits;

Memory_Level : in Memory_Level_Type := Default_Memory_Level;

Header : in Header_Type := Default);

-- Compressor initialization.

-- When Header parameter is Auto or Default, then default zlib header

-- would be provided for compressed data.

-- When Header is GZip, then gzip header would be set instead of

-- default header.

-- When Header is None, no header would be set for compressed data.

procedure Inflate_Init

(Filter : in out Filter_Type;

Window_Bits : in Window_Bits_Type := Default_Window_Bits;

Header : in Header_Type := Default);

-- Decompressor initialization.

-- Default header type mean that ZLib default header is expecting in the

-- input compressed stream.

-- Header type None mean that no header is expecting in the input stream.

-- GZip header type mean that GZip header is expecting in the

-- input compressed stream.

-- Auto header type mean that header type (GZip or Native) would be

-- detected automatically in the input stream.

-- Note that header types parameter values None, GZip and Auto are

-- supported for inflate routine only in ZLib versions 1.2.0.2 and later.

-- Deflate_Init is supporting all header types.

function Is_Open (Filter : in Filter_Type) return Boolean;

pragma Inline (Is_Open);

-- Is the filter opened for compression or decompression.

procedure Close

(Filter : in out Filter_Type;

Ignore_Error : in Boolean := False);

-- Closing the compression or decompressor.

-- If stream is closing before the complete and Ignore_Error is False,

-- The exception would be raised.

generic

with procedure Data_In

(Item : out Ada.Streams.Stream_Element_Array;

Last : out Ada.Streams.Stream_Element_Offset);

with procedure Data_Out

(Item : in Ada.Streams.Stream_Element_Array);

procedure Generic_Translate

(Filter : in out Filter_Type;

In_Buffer_Size : in Integer := Default_Buffer_Size;

Out_Buffer_Size : in Integer := Default_Buffer_Size);

-- Compress/decompress data fetch from Data_In routine and pass the result

-- to the Data_Out routine. User should provide Data_In and Data_Out

-- for compression/decompression data flow.

-- Compression or decompression depend on Filter initialization.

function Total_In (Filter : in Filter_Type) return Count;

pragma Inline (Total_In);

-- Returns total number of input bytes read so far

function Total_Out (Filter : in Filter_Type) return Count;

pragma Inline (Total_Out);

-- Returns total number of bytes output so far

function CRC32

(CRC : in Unsigned_32;

Data : in Ada.Streams.Stream_Element_Array)

return Unsigned_32;

pragma Inline (CRC32);

-- Compute CRC32, it could be necessary for make gzip format

procedure CRC32

(CRC : in out Unsigned_32;

Data : in Ada.Streams.Stream_Element_Array);

pragma Inline (CRC32);

-- Compute CRC32, it could be necessary for make gzip format

-------------------------------------------------

-- Below is more complex low level routines. --

-------------------------------------------------

procedure Translate

(Filter : in out Filter_Type;

In_Data : in Ada.Streams.Stream_Element_Array;

In_Last : out Ada.Streams.Stream_Element_Offset;

Out_Data : out Ada.Streams.Stream_Element_Array;

Out_Last : out Ada.Streams.Stream_Element_Offset;

Flush : in Flush_Mode);

-- Compress/decompress the In_Data buffer and place the result into

-- Out_Data. In_Last is the index of last element from In_Data accepted by

-- the Filter. Out_Last is the last element of the received data from

-- Filter. To tell the filter that incoming data are complete put the

-- Flush parameter to Finish.

function Stream_End (Filter : in Filter_Type) return Boolean;

pragma Inline (Stream_End);

-- Return the true when the stream is complete.

procedure Flush

(Filter : in out Filter_Type;

Out_Data : out Ada.Streams.Stream_Element_Array;

Out_Last : out Ada.Streams.Stream_Element_Offset;

Flush : in Flush_Mode);

pragma Inline (Flush);

-- Flushing the data from the compressor.

generic

with procedure Write

(Item : in Ada.Streams.Stream_Element_Array);

-- User should provide this routine for accept

-- compressed/decompressed data.

Buffer_Size : in Ada.Streams.Stream_Element_Offset

:= Default_Buffer_Size;

-- Buffer size for Write user routine.

procedure Write

(Filter : in out Filter_Type;

Item : in Ada.Streams.Stream_Element_Array;

Flush : in Flush_Mode := No_Flush);

-- Compress/Decompress data from Item to the generic parameter procedure

-- Write. Output buffer size could be set in Buffer_Size generic parameter.

generic

with procedure Read

(Item : out Ada.Streams.Stream_Element_Array;

Last : out Ada.Streams.Stream_Element_Offset);

-- User should provide data for compression/decompression

-- thru this routine.

Buffer : in out Ada.Streams.Stream_Element_Array;

-- Buffer for keep remaining data from the previous

-- back read.

Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset;

-- Rest_First have to be initialized to Buffer'Last + 1

-- Rest_Last have to be initialized to Buffer'Last

-- before usage.

Allow_Read_Some : in Boolean := False;

-- Is it allowed to return Last < Item'Last before end of data.

procedure Read

(Filter : in out Filter_Type;

Item : out Ada.Streams.Stream_Element_Array;

Last : out Ada.Streams.Stream_Element_Offset;

Flush : in Flush_Mode := No_Flush);

-- Compress/Decompress data from generic parameter procedure Read to the

-- Item. User should provide Buffer and initialized Rest_First, Rest_Last

-- indicators. If Allow_Read_Some is True, Read routines could return

-- Last < Item'Last only at end of stream.

private

use Ada.Streams;

pragma Assert (Ada.Streams.Stream_Element'Size = 8);

pragma Assert (Ada.Streams.Stream_Element'Modulus = 2**8);

type Flush_Mode is new Integer range 0 .. 5;

type Compression_Method is new Integer range 8 .. 8;

type Strategy_Type is new Integer range 0 .. 3;

No_Flush : constant Flush_Mode := 0;

Partial_Flush : constant Flush_Mode := 1;

Sync_Flush : constant Flush_Mode := 2;

Full_Flush : constant Flush_Mode := 3;

Finish : constant Flush_Mode := 4;

Block_Flush : constant Flush_Mode := 5;

Filtered : constant Strategy_Type := 1;

Huffman_Only : constant Strategy_Type := 2;

RLE : constant Strategy_Type := 3;

Default_Strategy : constant Strategy_Type := 0;

Deflated : constant Compression_Method := 8;

type Z_Stream;

type Z_Stream_Access is access all Z_Stream;

type Filter_Type is tagged limited record

Strm : Z_Stream_Access;

Compression : Boolean;

Stream_End : Boolean;

Header : Header_Type;

CRC : Unsigned_32;

Offset : Stream_Element_Offset;

-- Offset for gzip header/footer output.

end record;

end ZLib;