/*-------------------------------------------------------------*/
/*--- Public header file for the library.                   ---*/
/*---                                               bzlib.h ---*/
/*-------------------------------------------------------------*/

/* ------------------------------------------------------------------
   This file is part of bzip2/libbzip2, a program and library for
   lossless, block-sorting data compression.

   bzip2/libbzip2 version 1.0.8 of 13 July 2019
   Copyright (C) 1996-2019 Julian Seward <jseward@acm.org>

   Please read the WARNING, DISCLAIMER and PATENTS sections in the 
   README file.

   This program is released under the terms of the license contained
   in the file LICENSE.
   ------------------------------------------------------------------ */


#ifndef _BZLIB_H
#define _BZLIB_H

#ifdef __cplusplus
extern "C" {
#endif

#define BZ_RUN               0
#define BZ_FLUSH             1
#define BZ_FINISH            2

#define BZ_OK                0
#define BZ_RUN_OK            1
#define BZ_FLUSH_OK          2
#define BZ_FINISH_OK         3
#define BZ_STREAM_END        4
#define BZ_SEQUENCE_ERROR    (-1)
#define BZ_PARAM_ERROR       (-2)
#define BZ_MEM_ERROR         (-3)
#define BZ_DATA_ERROR        (-4)
#define BZ_DATA_ERROR_MAGIC  (-5)
#define BZ_IO_ERROR          (-6)
#define BZ_UNEXPECTED_EOF    (-7)
#define BZ_OUTBUFF_FULL      (-8)
#define BZ_CONFIG_ERROR      (-9)

#if (defined(__MSHORT__) || defined(__PUREC__) || defined(__AHCC__)) && (defined(__atarist__) || defined(__TOS__))
typedef long bz_int_t;
typedef unsigned long bz_uint_t;
#else
typedef int bz_int_t;
typedef unsigned int bz_uint_t;
#endif

#ifndef BZ_IMPORT
#define BZ_EXPORT
#endif

#ifndef BZ_NO_STDIO
/* Need a definitition for FILE */
#include <stdio.h>
#endif

#if defined(_WIN32) && !defined(__CYGWIN__)
#   include <windows.h>
#   ifdef small
      /* windows.h define small to char */
#      undef small
#   endif
#   ifndef __GNUC__
       /* Use these rules only for non-gcc native win32 */
#      ifdef BZ_EXPORT
#      define BZ_API(func) WINAPI func
#      define BZ_EXTERN extern
#      else
       /* import windows dll dynamically */
#      define BZ_API(func) (WINAPI * func)
#      define BZ_EXTERN
#      endif
#   else
       /* For gcc on native win32, use import library trampoline       */
       /* functions on DLL import.  This avoids requiring clients to   */
       /* use special compilation flags depending on whether eventual  */
       /* link will be against static libbz2 or against DLL, at the    */
       /* expense of a small loss of efficiency. */

       /* Because libbz2 does not export any DATA items, GNU ld's      */
       /* "auto-import" is not a factor; the MinGW-built DLL can be    */
       /* used by other compilers, provided an import library suitable */
       /* for that compiler is (manually) constructed using the .def   */
       /* file and the appropriate tool. */
#      define BZ_API(func) func
#      define BZ_EXTERN extern
#   endif
#else
    /* non-win32 platforms, and cygwin */
#endif
#if defined(BZIP2_SLB) && (defined(__atarist__) || defined(__TOS__))
#  include <features.h>
#  define BZ_CALLBACK __CDECL
#  define BZ_API(func) __CDECL func
#endif

#ifndef BZ_API
#   define BZ_API(func) func
#endif
#ifndef BZ_EXTERN
#   define BZ_EXTERN extern
#endif
#ifndef BZ_CALLBACK
#   define BZ_CALLBACK
#endif


typedef 
   struct {
      const char *next_in;
      bz_uint_t avail_in;
      bz_uint_t total_in_lo32;
      bz_uint_t total_in_hi32;

      char *next_out;
      bz_uint_t avail_out;
      bz_uint_t total_out_lo32;
      bz_uint_t total_out_hi32;

      void *state;

      void *BZ_CALLBACK (*bzalloc)(void *,bz_int_t,bz_int_t);
      void BZ_CALLBACK (*bzfree)(void *,void *);
      void *opaque;
   } 
   bz_stream;


/*-- Core (low-level) library functions --*/

BZ_EXTERN bz_int_t BZ_API(BZ2_bzCompressInit) ( 
      bz_stream* strm, 
      bz_int_t        blockSize100k, 
      bz_int_t        verbosity, 
      bz_int_t        workFactor 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzCompress) ( 
      bz_stream* strm, 
      bz_int_t action 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzCompressEnd) ( 
      bz_stream* strm 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzDecompressInit) ( 
      bz_stream *strm, 
      bz_int_t       verbosity, 
      bz_int_t       small_
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzDecompress) ( 
      bz_stream* strm 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzDecompressEnd) ( 
      bz_stream *strm 
   );



/*-- High(er) level library functions --*/

#ifndef BZ_NO_STDIO
#define BZ_MAX_UNUSED 5000

typedef void BZFILE;

BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( 
      bz_int_t*  bzerror,   
      FILE* f, 
      bz_int_t   verbosity, 
      bz_int_t   small_,
      void* unused,    
      bz_int_t   nUnused 
   );

BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( 
      bz_int_t*    bzerror, 
      BZFILE* b 
   );

BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( 
      bz_int_t*    bzerror, 
      BZFILE* b, 
      void**  unused,  
      bz_int_t*    nUnused 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzRead) ( 
      bz_int_t*    bzerror, 
      BZFILE* b, 
      void*   buf, 
      bz_int_t     len 
   );

BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( 
      bz_int_t*  bzerror,      
      FILE* f, 
      bz_int_t   blockSize100k, 
      bz_int_t   verbosity, 
      bz_int_t   workFactor 
   );

BZ_EXTERN void BZ_API(BZ2_bzWrite) ( 
      bz_int_t*    bzerror, 
      BZFILE* b, 
      const void*   buf, 
      bz_int_t     len 
   );

BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( 
      bz_int_t*          bzerror, 
      BZFILE*       b, 
      bz_int_t           abandon, 
      bz_uint_t* nbytes_in, 
      bz_uint_t* nbytes_out 
   );

BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( 
      bz_int_t*          bzerror, 
      BZFILE*       b, 
      bz_int_t           abandon, 
      bz_uint_t* nbytes_in_lo32, 
      bz_uint_t* nbytes_in_hi32, 
      bz_uint_t* nbytes_out_lo32, 
      bz_uint_t* nbytes_out_hi32
   );
#endif


/*-- Utility functions --*/

BZ_EXTERN bz_int_t BZ_API(BZ2_bzBuffToBuffCompress) ( 
      char*         dest, 
      bz_uint_t* destLen,
      char*         source, 
      bz_uint_t  sourceLen,
      bz_int_t           blockSize100k, 
      bz_int_t           verbosity, 
      bz_int_t           workFactor 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzBuffToBuffDecompress) ( 
      char*         dest, 
      bz_uint_t* destLen,
      char*         source, 
      bz_uint_t  sourceLen,
      bz_int_t           small_, 
      bz_int_t           verbosity 
   );


/*--
   Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
   to support better zlib compatibility.
   This code is not _officially_ part of libbzip2 (yet);
   I haven't tested it, documented it, or considered the
   threading-safeness of it.
   If this code breaks, please contact both Yoshioka and me.
--*/

BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
      void
   );

#ifndef BZ_NO_STDIO
BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
      const char *path,
      const char *mode
   );

BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
      bz_int_t        fd,
      const char *mode
   );
         
BZ_EXTERN bz_int_t BZ_API(BZ2_bzread) (
      BZFILE* b, 
      void* buf, 
      bz_int_t len 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzwrite) (
      BZFILE* b, 
      const void*   buf, 
      bz_int_t     len 
   );

BZ_EXTERN bz_int_t BZ_API(BZ2_bzflush) (
      BZFILE* b
   );

BZ_EXTERN void BZ_API(BZ2_bzclose) (
      BZFILE* b
   );

BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
      BZFILE *b, 
      bz_int_t    *errnum
   );
#endif

#ifdef __cplusplus
}
#endif

#endif

/*-------------------------------------------------------------*/
/*--- end                                           bzlib.h ---*/
/*-------------------------------------------------------------*/
