PKWARE Implode/Explode

Hi Roger

I use pkzip but ran into problems with memory limitations on archiving a large number of files into a single compressed file.

If you are going to program for dos, you might want to consider the rar.exe for msdos.

i have been able to add a large number of files to one rar archieve where pkzip would crash and destroy my archieve files.

i had to end up splitting my files into separate pkzip files to be able to use pkzip.

i was doing this from batch files on a computer running msdos 6.22.

Also i had some problems with the way pkzip was using extended/expanded memory and also had other memory related problems with pkzip, buf i forgot exactly what.

I am not sure but i believe rar uses a much smaller memory to run and i had put it through some tough testing for archiving a great number of files.

So if you want to do some shelling to archive docouments, rar might be the way to go.

here is documentation from running RAR /? to retrieve info. Rar also can be run in menu mode, that i never did.

RAR 2.06 Copyright (c) 1993-98 Eugene Roshal 3 December 1998
Shareware version Type RAR -? for help

Usage: RAR <command> -<switch 1> -<switch N> <archive> <files...>
<@listfiles...> <path_to_extract\>
or RAR

<Commands>
a Add files to archive u Update files in archive
f Freshen files in archive m[f] Move to archive [files only]
x Extract files with full path e Extract files to current directory
d Delete files from archive v Verbosely list contents of archive
r Repair archive l List contents of archive
p Print file to stdout s Convert archive to SFX
t Test archive files c Add archive comment
en Enter to archive cf Add files comment
k Lock archive cw Write archive comment to file
rr[N] Add data recovery record

<Switches>
rr[N] Add data recovery record mm[f] Multimedia compression [force]
o+ Overwrite existing files o- Do not overwrite existing files
bw Black & white mode col Color mode
y Assume Yes on all queries sfx Create SFX archives
std Stdout mode b Enable backup archives
f Freshen files u Update files
c- Disable comments show ed Do not add empty directories
ep Exclude paths from names ep1 Exclude base dir from names
tk Keep original archive time tl Set archive time to latest file
cfg- Disable read configuration ems- Disable expanded memory usage
s[e,<N>] Create solid archive
s- Disable solid archiving
r Recurse subdirectories
r0 Recurse subdirectories for wildcard names only
z<file> Read archive comment from file
x<file> Exclude specified file
[email protected]<list> Exclude files in specified list file
v Create volumes with size autodetection
v<N>[k,b,f] Create volumes with size=<N>*1000 [*1024, *1]
vd Erase disk contents before creating volume
p<password> Set password
p- Do not query password
kb Keep broken extracted files
w<path> Assign work directory
m<0..5> Set compression level (0-store...3-default...5-maximal)

Press any key to continue ...
av Put authenticity verification (registered versions only)
av- Disable AV check
ds Disable name sort for solid archive
$[drive] Add/extract volume label
dh Disable file sharing
ac Clear Archive attribute after compression
ao Add files with Archive attribute set

end of help list using RAR /?

this is not the current verison, which is 3.71

paul

Actually they are trying to sell it for $1000+ to me, and if used on handhelds, etc a license for each of them that is probably your $400 level. I got them to send me a 30 day version, but nothing in BASIC, only C++...anyone good at converting?

Code:

//------------------------------------------------------------------------------
// pkcdl.h - Header for this library.
// PKCDL: $Revision: 23 $   $Modtime: 12/08/03 4:15p $
// Copyright 1998-2003 By PKWARE Inc. All Rights Reserved.
//------------------------------------------------------------------------------
#if !defined ( __PKCDL_H )
#define        __PKCDL_H
#ifdef __cplusplus
   extern "C" {
#else
      /* #define const */
#endif
/**
 * @file  pkcdl.h
 *
 * Public header for PKWARE call back data compression functions
 */
#if !defined (PKCALLBACK)
# ifdef _UNIX
#  define PKCALLBACK
# else
#  define  PKCALLBACK __cdecl
# endif
#endif
#if !defined (PKCALL)
# ifdef _UNIX
#  define PKCALL
# else
#  define PKCALL __cdecl
# endif
#endif
#if !defined (PKCDL_DECL)
# ifdef PKCDLDLL
#  define PKCDL_DECL __declspec(dllexport)
# else
#  define PKCDL_DECL
# endif
#endif
/**
 * Read buffer call back function definition.
 *
 * @param  buf  Pointer the buffer to fill with data
 * @param  size  The amount of data to read
 * @param  param  User specified call back pointer.
 *
 * @return  The actual amount of data read, must be less than or equal to
 *   size.
 */
typedef  unsigned int (PKCALLBACK *PKReadBuf)(void*         buf,
                                              unsigned int  size,
                                              void*         param);
/**
 * Write buffer call back function definition.
 *
 * @param  buf  Pointer to the buffer containing the data to write
 * @param  size  The size of the buffer
 * @param  param  User specified call back pointer.
 */
typedef  void (PKCALLBACK *PKWriteBuf)(const void*    buf,
                                       unsigned int   size,
                                       void*          param);
/**
 * Memory allocation call back function definition.
 *
 * @param  size  The size of the buffer to allocate
 * @param  param  User specified call back pointer.
 *
 * @return  A pointer to the allocated memory block or NULL if the allocation
 *   failed.
 */
typedef  void* (PKCALLBACK *PKAlloc)(unsigned int size, void* param);
/**
 * Memory free call back function definition.
 *
 * @param  pointer  The pointer to release
 * @param  param  User specified call back pointer
 */
typedef  void (PKCALLBACK *PKFree)(void* pointer, void* param);
/* encrypt/decrypt */
#define CRYPT_BUFFER_SIZE  3
/* FLAGS */
/** \defgroup Buffer_Type_Values Buffer Type Values
 * Defines for getting buffer sizes
@{
*/
/** \defgroup Type_Values Type Values
@{
**/
/** Compression */
#define PKCMP 0x0000
/** Extraction */
#define PKEXT 0x8000
/** @}
*/
/** \defgroup Algorithm_Values Algorithm Values
 * These values correspond to the compression method values as
 * stored in a ZIP file. 
@{
*/
/** Shrunk */
#define SHRUNK       0x0001
/** Implode */
#define IMPLODE      0x0006
/** Deflate */
#define DEFLATE      0x0008
/** Defalte64 */
#define DEFLATE64    0x0009
/** DCLImplode */
#define DCLIMPLODE   0x000a
/** BZIP2 (Unavailable) */
#define BZIP2_METHOD 0x000c
/** @}
*/
/** @}
*/
/** \defgroup  Data_Type_Values Data Type Values
@{
*/
/** Binary */
#define CMP_BINARY      0
/** ASCII */
#define CMP_ASCII       1
/** @}
*/
/** \defgroup  Dictionary_Sizes Dictionary Sizes
 * Dicitonary Sizes for implode
@{
*/
/** Dictionary size of 1024 */
#define CMP_IMPLODE_DICT_SIZE1   1024
/** Dictionary size of 2048 */
#define CMP_IMPLODE_DICT_SIZE2   2048
/** Dictionary size of 4096 */
#define CMP_IMPLODE_DICT_SIZE3   4096
/** @}
*/
/* deflate level */
/** Compression level 1 (Super Fast) */
#define CMP_DEFLATE_MIN_LEVEL    1 
/** Compression Level 9 (Extra) */
#define CMP_DEFLATE_MAX_LEVEL    9
/** pkzip204g compatibility flag for deflate/inflate */
#define CMP_204            1
/** \defgroup pkexpl_Dictionary_Sizes pkexpl Dictionary Sizes
 * mode and dictionary sizes for pkexpl()
@{
*/
/** A 4K sliding dictionary was used */ 
#define SD_4K              0
/** An 8K sliding dictionary was used */
#define SD_8K              2
/** 2 Shannon-Fano trees were used to encode the sliding dictionary output */
#define SF_2               0
/** 3 Shannon-Fano trees were used to encode the sliding dictionary output */
#define SF_3               4
/** @}
*/
 
/** \defgroup  ERROR_CODES Error Codes
@{
*/
/** No Error */
#define CMP_NO_ERROR          0
/** Invalid Dictionary Size */
#define CMP_INVALID_DICTSIZE  1
/** Invalid dictionary size for DCL Implode functions. 
    If this error is encountered during extraction, the data is corrupt, 
    or we are not correctly positioned at the beginning of the data*/
#define CMP_INVALID_MODE      2
/** Reported only during extraction if compressed data appears to be corrupt.*/
#define CMP_BAD_DATA          3
/** Operation aborted by user. Does not always indicate error condition.
    Check total processed sise and crc32 to determine if operation was
    really interrupted.*/
#define CMP_ABORT             4
/** Reported only during extraction if compressed data is appears to be corrupt.*/
#define CMP_BAD_TABLE      5
/** Reported only during extraction if compressed data is appears to be corrupt.*/
#define CMP_BAD_BLOCKTYPE  6
/** End of compressed data. This is equivalent of EOF situation. */
#define CMP_END_CMP        7
/** @}
*/
/* FUNCTIONS */
/* HELPER Functions */
/**
 * Get the size of the buffer needed for the DCL function proposed by the
 * type parameter.
 *
 * @param  uType  Type of function to determine a buffer size for.  Algorithm value 
 *   should be combined with compression or extraction 
 *   value (PKCMP or PKEXT) using the OR (|) function.
 *
 * @return  Returns the size required for the buffer.
 *
 * @see Buffer_Type_Values for possible values for the uType parameter.
 */
PKCDL_DECL unsigned long PKCALL pkGetBufferSize(unsigned long uType);
/**
 * Calculate the CRC value for the data buffer.
 *
 * @param  buffer  The buffer of data to calculate the CRC value for.
 *
 * @param  size  The size of the buffer of data.
 *
 * @param  old_crc  The previous CRC value from subsequent calculations.
 *
 * @return  Returns the new CRC value.
 */
PKCDL_DECL unsigned long PKCALL pkcrc32(const void*     buffer,
                                        unsigned long   size,
                                        unsigned long   old_crc);
/**
 * Calculate the CRC value for a single character.
 *
 * @param  ch  The character to calculate the CRC value for.
 *
 * @param  old_crc  The previous CRC value from subsequent calculations.
 *
 * @return  Returns the new CRC value.
 */
PKCDL_DECL unsigned long PKCALL pkcrc32ch(unsigned char ch, unsigned long old_crc);
 
/* COMPRESSION & DECOMPRESSION routines */
/**
 * Function to compress data using the DCL implode algorithm.
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to the parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  type  The data type (ASCII or binary) of the data to be compressed.
 *
 * @param  dsize  Dictionary size.
 *
 * @return  Returns the error code for the function.
 *
 * @see Data_Type_Values for possible values for the type parameter
 * @see Dictionary_Size for possible values for dsize
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkimplode(PKReadBuf      read_buf,
                                         PKWriteBuf     write_buf,
                                         void*          work_buf,
                                         void*          param,
                                         unsigned int   type,
                                         unsigned int   dsize);
/**
 * Function to decompress data using the DCL implode algorithm.
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkexplode(PKReadBuf   read_buf,
                                         PKWriteBuf  write_buf,
                                         void*       work_buf,
                                         void*       param);
/**
 * Function to reset the DCL implode algorithm.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  type  The data type (ASCII or binary) of the data to be compressed.
 *
 * @param  dsize  Dictionary size.
 *
 * @return  Returns the error code for the function.
 *
 * @see Data_Type_Values for possible values for the type parameter
 * @see Dictionary_Size for possible values for the dsize parameter
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkimplode_reset(PKWriteBuf  write_buf,
                                               void*       work_buf,
                                               void*       param,
                                               unsigned    int type,
                                               unsigned    int dsize);
/**
 * Writes additional data to be compressed using the DCL Implode method
 *
 * @param  work_buf  Pointer to the working buffer.
 * @param  data  Pointer to the data to be compressed
 * @param  size  The size of the data to be compressed
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkimplode_write(void*          work_buf,
                                               const void*    data,
                                               unsigned int   size);
/**
 * Finishes the DCL Implode compression operation and flushes any remaining data
 * in the compression buffer.
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkimplode_flush(void* work_buf);
 
/**
 * Function to compress data using the Deflate or Deflate64 algorithms
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  level  Level of compression: 1 to 9.
 *
 * @param  f204  2.04g compatible flag, make false for Deflate64.
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkdeflate(PKReadBuf      read_buf,
                                         PKWriteBuf     write_buf,
                                         void*          work_buf,
                                         void*          param,
                                         unsigned int   level,
                                         unsigned int   f204);
/**
 * Function to reset the Deflate or Deflate64 algorithm to begin 
 * compressing data.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  level  Level of compression: 1 to 9.
 *
 * @param  f204  2.04g compatible flag.  Make false (0) for deflate64.
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkdeflate_reset(PKWriteBuf     write_buf,
                                               void*          work_buf,
                                               void*          param,
                                               unsigned int   level,
                                               unsigned int   f204);
PKCDL_DECL unsigned int PKCALL pkdeflate_write(void*          work_buf,
                                               const void*    data,
                                               unsigned int   size);
PKCDL_DECL unsigned int PKCALL pkdeflate_flush(void* work_buf);
/**
 * Function to decompress data using the Deflate or Deflate64 algorithm.
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  f204  2.04g compatible flag.  Make false (0) for deflate64.
 *
 * @return  Returns the error code for the function.
 *
 * @see ERROR_CODES for possible return values
 *
 */
PKCDL_DECL unsigned int PKCALL pkinflate(PKReadBuf      read_buf,
                                         PKWriteBuf     write_buf,
                                         void*          work_buf,
                                         void*          param,
                                         unsigned int   f204);
/**
 * Function to decompress data using the implode algorithm.
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @param  mode  The dictionary size that was originally used to 
 *  compress the data.
 *
 * @return  Returns the error code for the function.
 *
 * @see pkexpl_Dictionary_Size for possible values for the mode parameter
 * @see ERROR_CODES for possible return values
 * 
 *
 */
PKCDL_DECL unsigned int PKCALL pkexpl(PKReadBuf      read_buf,
                                      PKWriteBuf     write_buf,
                                      void*          work_buf,
                                      void*          param,
                                      unsigned int   mode);
/**
 * Function to decompress data using the old PKWARE shrink algorithm.
 *
 * @param  read_buf  Pointer to read buffer function.
 *
 * @param  write_buf  Pointer to the write buffer function.
 *
 * @param  work_buf  Pointer to the working buffer.
 *
 * @param  param  Pointer to parameter to be passed to the read and 
 *    write buffer functions.
 *
 * @return  Returns the error code for the function.
 * @see ERROR_CODES for possible return values
 */
PKCDL_DECL unsigned int PKCALL pkunshrink(PKReadBuf  read_buf,
                                          PKWriteBuf write_buf,
                                          void*      work_buf,
                                          void*      param);
#ifdef __cplusplus
   }
#endif
#endif

Code:

//-----------------------------------------------------------------------------
// pkcdl_stream.h - Streaming PKCDL routines
// PKCDL: $Revision: 11 $   $Modtime: 12/08/03 4:19p $
// Copyright 2002 - 2003 by PKWARE, Inc.  All Rights Reserved.
//-----------------------------------------------------------------------------
#ifndef _PKCDL_STREAM_H
#define _PKCDL_STREAM_H
#ifdef __cplusplus
   extern "C" {
#endif
/**
 * @file  pkcdl_stream.h
 *
 * Public header for PKWARE stream data compression functions
 */
/** \defgroup PK_ACTION PK_ACTION codes
 * Action codes for compression
@{
*/
#define PK_ACTION_RUN               0
#define PK_ACTION_FLUSH             1
#define PK_ACTION_FINISH            2
/** @}*/
/* Allowed flush values */
#define PK_NO_FLUSH      0
#define PK_PARTIAL_FLUSH 1
#define PK_SYNC_FLUSH    2
#define PK_FULL_FLUSH    3
#define PK_FINISH        4
/** \defgroup Stream_Return_Codes Stream Return Codes
* Possible error codes for streaming functions
@{
*/
/** Return Codes - Normal events */
#define PKDCL_OK            0
/** All data from the input stream is read*/
#define PKDCL_STREAM_END    1
/** Need more data (dictionary)*/
#define PKDCL_NEED_DICT     2
/** Internal flag, not returned to user */
#define PKDCL_CONTINUE     10
/** Internal flag, not returned to user */
#define PKDCL_GET_INPUT    11
/* Return Codes - Errors/Special events */
/** NULL stream pointer */
#define PKDCL_STREAM_NULL_ERROR            (-1)
/** Corrupted data */
#define PKDCL_STREAM_NULL_STATE_ERROR      (-2)
/** Out of memory*/
#define PKDCL_STREAM_ALLOC_ERROR           (-3)
/** Corrupted data */
#define PKDCL_STREAM_LEVEL_ERROR           (-4)
/** Corrupted data */
#define PKDCL_STREAM_STRATEGY_ERROR        (-5)
/** Out of memory*/
#define PKDCL_MEM_INT_STATE_ERROR          (-10)
/** Internal flag, not returned to user */
#define PKDCL_MEM_INT_BUFFER_ERROR         (-11)
/** Corrupted data */
#define PKDCL_STATUS_ERROR                 (-20)
/** Internal flag, not returned to user */
#define PKDCL_DATA_IN_ERROR                (-21)
/** Internal flag, not returned to user */
#define PKDCL_DATA_OUT_ERROR               (-22)
/** Internal flag, not returned to user */
#define PKDCL_FLUSH_ERROR                  (-23)
/** Corrupted data */
#define PKDCL_NULL_DICTIONARY_ERROR        (-24)
/** Internal flag, not returned to user */
#define PKDCL_FINISH_ERROR                 (-25)
/** @}*/
/** Internal flag, not returned to user */
#define DEFLATE_DEFAULT_COMPRESSION    (-1)
/** Compression type options */
#define DEFLATE_EXE              0x100
#if !defined (PKCALL)
# ifdef _UNIX
#  define PKCALL
# else
#  define PKCALL __cdecl
# endif
#endif
typedef void *PVOID;
/**
 * Signature for user defined memory allocation function
 *
 * @param  opaque  User specified call back pointer.
 * @param  item  The number of items to allocate space for
 * @param  size  The size of each item
 *
 * @return  A pointer to the allocated memory
 */
typedef PVOID (*ALLOC_FUNC)(PVOID opaque, unsigned int items, unsigned int size);
/**
 * Signature for user defined memory free function
 *
 * @param  opaque  User specified call back pointer.
 * @param  address  The memory location to release.
 */
typedef void (*FREE_FUNC)(PVOID opaque, PVOID address);
struct internal_state;
typedef struct internal_state PKINT_STATE;
/**
 * Compression buffer structure used with streaming compression interfaces.
 *
 */
typedef struct {
   /** Pointer to next input byte */
   unsigned char* next_in;
   /** Number of bytes available in the input buffer */
   unsigned int   avail_in;
   /** Number of bytes read from the input buffer (least significant) */
   unsigned int   total_in_lo32;
   /** Number of bytes read from the input buffer (most significant) */
   unsigned int   total_in_hi32;
   /** Pointer to next output byte */
   unsigned char* next_out;
   /** Number of bytes available in the output buffer */
   unsigned int   avail_out;
   /** Number of bytes written to the output buffer (least significant) */
   unsigned int   total_out_lo32;
   /** Number of bytes written to the output buffer (most significant) */
   unsigned int   total_out_hi32;
   /** Last error message, or NULL if no error */
   char *msg;
   /** Internal pointer to state information for the algorithm */
   PKINT_STATE *state;
   /** Pointer to custom alloc() function */
   ALLOC_FUNC   zalloc;
   /** Pointer to custom free() function */
   FREE_FUNC    zfree;
   /** User defined pointer */
   void* opaque;
   /** CRC32 value of uncompressed data (not currently used) */
   unsigned long crc32;
}  PKCmpStreamStruct;
typedef PKCmpStreamStruct* pPKCmpStream;
typedef PKCmpStreamStruct   PKCmpStream;
/* ----------------------------------------------------------
 * Streaming DCL Implode/Explode Functions
 * ----------------------------------------------------------
 */
/**
 * Initializes streaming DCL Implode compression
 *
 * @param  pStream  Pointer to compression stream structure
 * @param  uiTypeOfData  Indicates if the data to be compressed is ASCII or
 *   binary (CMP_ASCII or CMP_BINARY).
 * @param  uiDictionarySize  Size of the sliding dictionary to use
 *         (1024, 2048, or 4096)
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkImplodeStreamInit(PKCmpStream *pStream, int uiTypeOfData,
                               int uiDictionarySize);
/**
 * Performs DCL Implode compression
 *
 * @param  pStream  Pointer to the compression stream structure.
 * @param  action  The compression action must be one of the
 *   PK_ACTION codes
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 * @see PK_ACTION for possible values for action
 */
int PKCALL pkImplodeStream(PKCmpStream *pStream, int action);
/**
 * Finishes streaming DCL Implode compression and releases memory that
 * had been allocated by the compression engine.
 *
 * @param  pStream  Pointer to the compression stream structure.
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkImplodeStreamEnd(PKCmpStream *pStream);
/**
 * Initializes streaming DCL Explode decompression
 *
 * @param  pStream  Pointer to the compression stream structure
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkExplodeStreamInit(PKCmpStream *pStream);
/**
 * Performs streaming DCL Explode decompression
 *
 * @param  pStream  Pointer to the compression stream structure
 * @param  action  The decompression action must be one of the
 *   PK_ACTION codes
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 * @see PK_ACTION for possible values for action
 */
int PKCALL pkExplodeStream(PKCmpStream *pStream, int action);
/**
 * Finishes streaming DCL Explode decompression and releases memory that
 * had been allocated by the decompression engine.
 *
 * @param  pStream  Pointer to the compression stream structure
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkExplodeStreamEnd(PKCmpStream *pStream);
/* ----------------------------------------------------------------------
 * Streaming Deflate and Inflate Functions
 * ----------------------------------------------------------------------
 */
/**
 * Initializes streaming Deflate compression
 *
 * @param  pStream  Pointer to the compression stream structure
 * @param  level  The compression level (1-9) that should be used
 * @param  deflate  Indicates if standard deflate should be used
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkDeflateStreamInit(PKCmpStream *pStream, int level, char b204);
/**
 * Performs streaming Deflate decompression
 *
 * @param  pStream  Pointer to the compression stream structure
 * @param  action  The decompression action must be one of the
 *   PK_ACTION codes
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkDeflateStream(PKCmpStream *pStream, int action);
/**
 * Finishes streaming Deflate decompression and releases memory that
 * had been allocated by the decompression engine.
 *
 * @param  pStream  Pointer to the compression stream structure
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkDeflateStreamEnd(PKCmpStream *pStream);
/**
 * Initializes streaming Inflate compression
 *
 * @param  pStream  Pointer to the compression stream structure
 * @param  b204  Indicates if standard (2.04g) Deflate should be used.
 *   Set to false (0) to indicate the deflate64 algorithm.
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 */
int PKCALL pkInflateStreamInit(PKCmpStream *pStream, char b204);
/**
 * Performs streaming Inflate decompression
 *
 * @param  pStream  Pointer to the compression stream structure
 * @param  action  The decompression action must be one of the
 *   PK_ACTION codes
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 * @see PK_ACTION for possible values for action
 */
int PKCALL pkInflateStream(PKCmpStream *pStream, int action);
/**
 * Finishes streaming Inflate decompression and releases memory that
 * had been allocated by the decompression engine.
 *
 * @param  pStream  Pointer to the compression stream structure
 *
 * @return  Returns a status code to indicate success or failure.
 *
 * @see Stream_Return_Codes for possible return values
 * @see PK_ACTION for possible values for action
 */
int PKCALL pkInflateStreamEnd(PKCmpStream *pStream);
#ifdef __cplusplus
   }
#endif
#endif // _PKCDL_STREAM_H

I think the version I need would be for streams since I'll be manipulating data in memory and not files...

Announcement

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment:

Leave a comment: