fci.pas

fci

 *      returns FALSE;
 }

type
  TFNFCIGETNEXTCABINET = function (pccab : PCCAB; cbPrevCab : TULONG; 
    pv : Pointer) : Bool; cdecl;
  PFNFCIGETNEXTCABINET = TFNFCIGETNEXTCABINET;
  
                                       { pfnfcignc }

{**    FNFCIFILEPLACED - Notify FCI client that file was placed
 *
 *  Entry:
 *      pccab         - cabinet structure to fill in, with copy of previous one
 *      pszFile       - name of file, from cabinet
 *      cbFile        - length of file
 *      fContinuation - true if this is a later segment of a continued file
 *      pv            - the context of the client
 *
 *  Exit-Success:
 *      return value anything but -1
 *
 *  Exit-Failure:
 *      return value -1 means to abort
 }

type
  TFNFCIFILEPLACED = function (pccab : PCCAB; pszFile : PChar; 
    cbFile : Longint; fContinuation : Bool; pv : Pointer) : Integer; cdecl;
  PFNFCIFILEPLACED = TFNFCIFILEPLACED;
  
                                       { pfnfcifp }

{**    FNCDIGETOPENINFO - Open source file, get date/time/attribs
 *
 *  Entry:
 *      pszName  -- complete path to filename
 *      pdate    -- location to return FAT-style date code
 *      ptime    -- location to return FAT-style time code
 *      pattribs -- location to return FAT-style attributes
 *      pv       -- client's context
 *
 *  Exit-Success:
 *      Return value is file handle of open file to read
 *
 *  Exit-Failure:
 *      Return value is -1
 }

type
  TFNFCIGETOPENINFO = function (pszName : PChar; var pdate : TUSHORT; 
    var ptime : TUSHORT; var pattribs : TUSHORT; err : PInteger; pv : Pointer) : 
    Integer; cdecl;
  PFNFCIGETOPENINFO = TFNFCIGETOPENINFO;
  
                                       { pfnfcigoi }

{**    FNFCISTATUS - Status/Cabinet Size callback
 *
 *  Entry:
 *      typeStatus == statusFile if compressing a block into a folder
 *                      cb1 = Size of compressed block
 *                      cb2 = Size of uncompressed block
 *
 *      typeStatus == statusFolder if adding a folder to a cabinet
 *                      cb1 = Amount of folder copied to cabinet so far
 *                      cb2 = Total size of folder
 *
 *      typeStatus == statusCabinet if writing out a complete cabinet
 *                      cb1 = Estimated cabinet size that was previously
 *                              passed to fnfciGetNextCabinet().
 *                      cb2 = Actual cabinet size
 *                    NOTE: Return value is desired client size for cabinet
 *                          file.  FCI updates the maximum cabinet size
 *                          remaining using this value.  This allows a client
 *                          to generate multiple cabinets per disk, and have
 *                          FCI limit the size correctly -- the client can do
 *                          cluster size rounding on the cabinet size!
 *                          The client should either return cb2, or round cb2
 *                          up to some larger value and return that.
 *  Exit-Success:
 *      Returns anything other than -1;
 *      NOTE: See statusCabinet for special return values!
 *
 *  Exit-Failure:
 *      Returns -1 to signal that FCI should abort;
 }

const
  statusFile = 0;
  statusFolder = 1;
  statusCabinet = 2;

type
  TFNFCISTATUS = function (typeStatus : TUINT; cb1 : TULONG; cb2 : TULONG; 
    pv : Pointer) : Longint; cdecl;
  PFNFCISTATUS = TFNFCISTATUS;
  
                                       { pfnfcis }

{**    FNFCIGETTEMPFILE - Callback, requests temporary file name
 *
 *  Entry:
 *      pszTempName - Buffer to receive complete tempfile name
 *      cbTempName  - Size of pszTempName buffer
 *
 *  Exit-Success:
 *      return TRUE
 *
 *  Exit-Failure:
 *      return FALSE; could not create tempfile, or buffer too small
 *
 *  Note:
 *      It is conceivable that this function may return a filename
 *      that will already exist by the time it is opened.  For this
 *      reason, the caller should make several attempts to create
 *      temporary files before giving up.
 }

type
  TFNFCIGETTEMPFILE = function (pszTempName : PChar; cbTempName : Integer; 
    pv : Pointer) : Bool; cdecl;
  PFNFCIGETTEMPFILE = TFNFCIGETTEMPFILE;

                                       { pfnfcigtf }

{**    FCICreate -- create an FCI context (an open CAB, an open FOL)
 *
 *  Entry:
 *      perf      - structure where we return error codes
 *      pfnfcifp  - callback to inform caller of eventual dest of files
 *      pfna      - memory allocation function callback
 *      pfnf      - memory free function callback
 *      pfnfcigtf - temp file name generator callback
 *      pccab     - pointer to cabinet/disk name & size structure
 *
 *  Notes:
 *  (1) The alloc/free callbacks must remain valid throughout
 *      the life of the context, up to and including the call to
 *      FCIDestroy.
 *  (2) The perf pointer is stored in the compression context (HCI),
 *      and any errors from subsequent FCI calls are stored in the
 *      erf that was passed in on *this* call.
 *
 *  Exit-Success:
 *      Returns non-NULL handle to an FCI context.
 *
 *  Exit-Failure:
 *      Returns NULL, perf filled in.
 }

  function FCICreate (perf : PERF; pfnfcifp : PFNFCIFILEPLACED; 
    pfna : PFNFCIALLOC; pfnf : PFNFCIFREE; pfnopen : PFNFCIOPEN; 
    pfnread : PFNFCIREAD; pfnwrite : PFNFCIWRITE; pfnclose : PFNFCICLOSE; 
    pfnseek : PFNFCISEEK; pfndelete : PFNFCIDELETE; 
  pfnfcigtf : PFNFCIGETTEMPFILE; pccab : PCCAB; pv : Pointer) : HFCI; cdecl;

{**   FCIAddFile - Add a disk file to a folder/cabinet
 *
 *  Entry:
 *      hfci          - FCI context handle
 *      pszSourceFile - Name of file to add to folder
 *      pszFileName   - Name to store into folder/cabinet
 *      fExecute      - Flag indicating execute on extract
 *      pfn_progress  - Progress callback
 *      pfnfcignc     - GetNextCabinet callback
 *      pfnfcis       - Status callback
 *      pfnfcigoi     - OpenInfo callback
 *      typeCompress  - Type of compression to use for this file
 *      pv            - pointer to caller's internal context
 *
 *  Exit-Success:
 *      returns TRUE
 *
 *  Exit-Failure:
 *      returns FALSE, error filled in
 *    
 *    This is the main function used to add file(s) to a cabinet
 *    or series of cabinets.  If the current file causes the current
 *    folder/cabinet to overflow the disk image currently being built,
 *    the cabinet will be terminated, and a new cabinet/disk name will
 *    be prompted for via a callback.  The pending folder will be trimmed
 *    of the data which has already been generated in the finished cabinet.
 }

  function FCIAddFile (hfci : HFCI; pszSourceFile : PChar; pszFileName : PChar;
    fExecute : Bool; pfnfcignc : PFNFCIGETNEXTCABINET; pfnfcis : PFNFCISTATUS;
  pfnfcigoi : PFNFCIGETOPENINFO; typeCompress : TCOMP) : Bool; cdecl;

{**   FCIFlushCabinet - Complete the current cabinet under construction
 *
 *  This will cause the current cabinet (assuming it is not empty) to
 *  be gathered together and written to disk.
 *
 *  Entry:
 *      hfci        - FCI context
 *      fGetNextCab - TRUE  => Call GetNextCab to get continuation info;
 *                    FALSE => Don't call GetNextCab unless this cabinet
 *                             overflows.
 *      pfnfcignc   - callback function to get continuation cabinets
 *      pfnfcis     - callback function for progress reporting
 *      pv          - caller's internal context for callbacks
 *
 *  Exit-Success:
 *      return code TRUE
 *
 *  Exit-Failure:
 *      return code FALSE, error structure filled in
 }

  function FCIFlushCabinet (hfci : HFCI; fGetNextCab : Bool; 
  pfnfcignc : PFNFCIGETNEXTCABINET; pfnfcis : PFNFCISTATUS) : Bool; cdecl;

{**   FCIFlushFolder - Complete the current folder under construction
 *
 *  This will force the termination of the current folder, which may or
 *  may not cause one or more cabinet files to be completed.
 *
 *  Entry:
 *      hfci        - FCI context
 *      GetNextCab  - callback function to get continuation cabinets
 *      pfnProgress - callback function for progress reporting
 *      pv          - caller's internal context for callbacks
 *
 *  Exit-Success:
 *      return code TRUE
 *
 *  Exit-Failure:
 *      return code FALSE, error structure filled in
 }

  function FCIFlushFolder (hfci : HFCI; pfnfcignc : PFNFCIGETNEXTCABINET; 
  pfnfcis : PFNFCISTATUS) : Bool; cdecl;

{**    FCIDestroy - Destroy a FCI context and delete temp files
 *
 *  Entry:
 *      hfci - FCI context
 *
 *  Exit-Success:
 *      return code TRUE
 *
 *  Exit-Failure:
 *      return code FALSE, error structure filled in
 }

function FCIDestroy (hfci : HFCI) : Bool; cdecl;

function CompressionTypeFromTCOMP (tc : TCOMP) : Integer;

function CompressionLevelFromTCOMP (tc : TCOMP) : Integer;

function CompressionMemoryFromTCOMP (tc : TCOMP) : Integer;

function TCOMPfromTypeLevelMemory (t : Integer; l : Integer; m : Integer) : Integer;

function LZXCompressionWindowFromTCOMP (tc : TCOMP) : Integer;

function TCOMPfromLZXWindow (w : Integer) : Integer;

implementation

const
  CabinetDll = 'cabinet.dll';

function FCICreate; external CabinetDll name 'FCICreate';
function FCIAddFile; external CabinetDll name 'FCIAddFile';
function FCIFlushCabinet; external CabinetDll name 'FCIFlushCabinet';
function FCIFlushFolder; external CabinetDll name 'FCIFlushFolder';
function FCIDestroy; external CabinetDll name 'FCIDestroy';

function CompressionTypeFromTCOMP (tc : TCOMP) : Integer;
begin
  Result:=((tc) and $000F);
end;

function CompressionLevelFromTCOMP (tc : TCOMP) : Integer;
begin
  Result:=(((tc) and $00F0) shr 4);
end;

function CompressionMemoryFromTCOMP (tc : TCOMP) : Integer;
begin
  Result:=(((tc) and $1F00) shr 8);
end;

function TCOMPfromTypeLevelMemory (t : Integer; l : Integer; m : Integer) : Integer;
begin
  Result:=(((m) shl 8) or ((l) shl 4) or (t));
end;

function LZXCompressionWindowFromTCOMP (tc : TCOMP) : Integer;
begin
  Result:=(((tc) and $1F00) shr 8);
end;

function TCOMPfromLZXWindow (w : Integer) : Integer;
begin
  Result:=(((w) shl 8) or ($0003));
end;

end.