//Types of compression methods supported
typedef enum
{
  LZ4 = 0,
  LZ4HC,
  LZMA,
  BZIP2,
  SNAPPY,
  ZLIB,
  ZSTD,
  AOCL_COMPRESSOR_ALGOS_NUM
} aocl_compression_type;

typedef struct
{
  char *inBuf;         /**<  Pointer to input buffer data                           */
  char *outBuf;        /**<  Pointer to output buffer data                          */
  char *workBuf;       /**<  Pointer to temporary work buffer                       */
  size_t inSize;       /**<  Input data length                                      */
  size_t outSize;      /**<  Output data length                                     */
  size_t level;        /**<  Requested compression level                            */
  size_t optVar;       /**<  Additional variables or parameters                     */
  int numThreads;      /**<  Number of threads available for multi-threading        */
  int numMPIranks;     /**<  Number of available multi-core MPI ranks               */
  size_t memLimit;     /**<  Maximum memory limit for compression/decompression     */
  int measureStats;    /**<  Measure speed and size of compression/decompression    */
  uint64_t cSize;      /**<  Size of compressed output                              */
  uint64_t dSize;      /**<  Size of decompressed output                            */
  uint64_t cTime;      /**<  Time to compress input                                 */
  uint64_t dTime;      /**<  Time to decompress input                               */
  float cSpeed;        /**<  Speed of compression                                   */
  float dSpeed;        /**<  Speed of decompression                                 */
  int optOff;          /**<  Turn off all optimizations                             */
  int optLevel;        /**<  Optimization level:  \n
                             0 - non-SIMD algorithmic optimizations, \n
                             1 - SSE2 optimizations, \n
                             2 - AVX optimizations, \n
                             3 - AVX2 optimizations, \n
                             4 - AVX512 optimizations                               */
} aocl_compression_desc;

typedef enum
{
  ERR_MEMORY_ALLOC = -6,    ///<Memory allocation failure
  ERR_INVALID_INPUT,        ///<Invalid input parameter provided
  ERR_UNSUPPORTED_METHOD,   ///<compression method not supported by the library
  ERR_EXCLUDED_METHOD,      ///<compression method excluded from this library build
  ERR_COMPRESSION_FAILED,   ///<failure in compression/decompression
  ERR_COMPRESSION_INVALID_OUTPUT ///<invalid compression/decompression output
} aocl_error_type;

//Interface API to provide the maximum size that compression may
//output in a "worst case" scenario (input data not compressible)
int64_t aocl_llc_compressBound(aocl_compression_type codec_type,
  size_t inSize);

//Interface API to compress data
int64_t aocl_llc_compress(aocl_compression_desc *handle,
  aocl_compression_type codec_type);

//Interface API to decompress data
int64_t aocl_llc_decompress(aocl_compression_desc *handle,
  aocl_compression_type codec_type);

//Interface API to setup the compression method
int32_t aocl_llc_setup(aocl_compression_desc *handle,
  aocl_compression_type codec_type);

//Interface API to destroy the compression method
void aocl_llc_destroy(aocl_compression_desc *handle,
  aocl_compression_type codec_type);

//Interface API to get compression library version string
const char* aocl_llc_version(void);

//Interface API to get the length of the RAP frame in the compressed stream
int32_t aocl_llc_skip_rap_frame(char* src, int32_t src_size);

//bzip2 Interface API to compress data
int BZ2_bzBuffToBuffCompress(char* dest, unsigned int* destLen,
  char* source, unsigned int sourceLen, int blockSize100k,
  int verbosity, int workFactor);

//bzip2 Interface API to decompress data
int BZ2_bzBuffToBuffDecompress(char* dest, unsigned int* destLen,
  char* source, unsigned int sourceLen, int small, int verbosity);

//lz4 Interface API to compress data
int LZ4_compress_default(const char* src, char* dst,
  int srcSize, int dstCapacity);

//lz4 Interface API to decompress data
int LZ4_decompress_safe(const char* src, char* dst,
  int compressedSize, int dstCapacity);

//lz4hc Interface API to compress data
int LZ4_compress_HC(const char* src, char* dst,
  int srcSize, int dstCapacity, int compressionLevel);

//lz4hc Interface API to decompress data
int LZ4_decompress_safe(const char* src, char* dst,
  int compressedSize, int dstCapacity);

//lzma Interface API to compress data
int LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
  const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize,
  int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc,
  ISzAllocPtr allocBig);

//lzma Interface API to decompress data
int LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
  const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
  ELzmaStatus *status, ISzAllocPtr alloc);

//snappy Interface API to compress data
void RawCompress(const char* input, size_t input_length, char* compressed,
  size_t* compressed_length);

//snappy Interface API to decompress data
bool RawUncompress(const char* compressed, size_t compressed_length,
  char* uncompressed);

//zlib Interface API to compress data
Int compress2(unsigned char *dest, unsigned long *destLen,
  const unsigned char *source, unsigned long sourceLen, int level);

//zlib Interface API to decompress data
int uncompress(unsigned char *dest, unsigned long *destLen,
  const unsigned char *source, unsigned long sourceLen);

//zstd Interface API to compress data
size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx, void* dst,
  size_t dstCapacity, const void* src, size_t srcSize,
  const void* dict,size_t dictSize, ZSTD_parameters params);

//zstd Interface API to decompress data
size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
  void* dst, size_t dstCapacity, const void* src, size_t srcSize);