text: /* 7z.h -- 7z interface
  2010-03-11 : Igor Pavlov : Public domain */
  
  #ifndef __7Z_H
  #define __7Z_H
  
  #include "7zBuf.h"
  
  EXTERN_C_BEGIN
  
  #define k7zStartHeaderSize 0x20
  #define k7zSignatureSize 6
  extern Byte k7zSignature[k7zSignatureSize];
  #define k7zMajorVersion 0
  
  enum EIdEnum
  {
    k7zIdEnd,
    k7zIdHeader,
    k7zIdArchiveProperties,
    k7zIdAdditionalStreamsInfo,
    k7zIdMainStreamsInfo,
    k7zIdFilesInfo,
    k7zIdPackInfo,
    k7zIdUnpackInfo,
    k7zIdSubStreamsInfo,
    k7zIdSize,
    k7zIdCRC,
    k7zIdFolder,
    k7zIdCodersUnpackSize,
    k7zIdNumUnpackStream,
    k7zIdEmptyStream,
    k7zIdEmptyFile,
    k7zIdAnti,
    k7zIdName,
    k7zIdCTime,
    k7zIdATime,
    k7zIdMTime,
    k7zIdWinAttributes,
    k7zIdComment,
    k7zIdEncodedHeader,
    k7zIdStartPos,
    k7zIdDummy
  };
  
  typedef struct
  {
    UInt32 NumInStreams;
    UInt32 NumOutStreams;
    UInt64 MethodID;
    CBuf Props;
  } CSzCoderInfo;
  
  void SzCoderInfo_Init(CSzCoderInfo *p);
  void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc);
  
  typedef struct
  {
    UInt32 InIndex;
    UInt32 OutIndex;
  } CSzBindPair;
  
  typedef struct
  {
    CSzCoderInfo *Coders;
    CSzBindPair *BindPairs;
    UInt32 *PackStreams;
    UInt64 *UnpackSizes;
    UInt32 NumCoders;
    UInt32 NumBindPairs;
    UInt32 NumPackStreams;
    int UnpackCRCDefined;
    UInt32 UnpackCRC;
  
    UInt32 NumUnpackStreams;
  } CSzFolder;
  
  void SzFolder_Init(CSzFolder *p);
  UInt64 SzFolder_GetUnpackSize(CSzFolder *p);
  int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex);
  UInt32 SzFolder_GetNumOutStreams(CSzFolder *p);
  UInt64 SzFolder_GetUnpackSize(CSzFolder *p);
  
  SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes,
      ILookInStream *stream, UInt64 startPos,
      Byte *outBuffer, size_t outSize, ISzAlloc *allocMain);
  
  typedef struct
  {
    UInt32 Low;
    UInt32 High;
  } CNtfsFileTime;
  
  typedef struct
  {
    CNtfsFileTime MTime;
    UInt64 Size;
    UInt32 Crc;
    UInt32 Attrib;
    Byte HasStream;
    Byte IsDir;
    Byte IsAnti;
    Byte CrcDefined;
    Byte MTimeDefined;
    Byte AttribDefined;
  } CSzFileItem;
  
  void SzFile_Init(CSzFileItem *p);
  
  typedef struct
  {
    UInt64 *PackSizes;
    Byte *PackCRCsDefined;
    UInt32 *PackCRCs;
    CSzFolder *Folders;
    CSzFileItem *Files;
    UInt32 NumPackStreams;
    UInt32 NumFolders;
    UInt32 NumFiles;
  } CSzAr;
  
  void SzAr_Init(CSzAr *p);
  void SzAr_Free(CSzAr *p, ISzAlloc *alloc);
  
  
  /*
    SzExtract extracts file from archive
  
    *outBuffer must be 0 before first call for each new archive.
  
    Extracting cache:
      If you need to decompress more than one file, you can send
      these values from previous call:
        *blockIndex,
        *outBuffer,
        *outBufferSize
      You can consider "*outBuffer" as cache of solid block. If your archive is solid,
      it will increase decompression speed.
    
      If you use external function, you can declare these 3 cache variables
      (blockIndex, outBuffer, outBufferSize) as static in that external function.
      
      Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
  */
  
  typedef struct
  {
    CSzAr db;
    
    UInt64 startPosAfterHeader;
    UInt64 dataPos;
  
    UInt32 *FolderStartPackStreamIndex;
    UInt64 *PackStreamStartPositions;
    UInt32 *FolderStartFileIndex;
    UInt32 *FileIndexToFolderIndexMap;
  
    size_t *FileNameOffsets; /* in 2-byte steps */
    CBuf FileNames;  /* UTF-16-LE */
  } CSzArEx;
  
  void SzArEx_Init(CSzArEx *p);
  void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
  UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
  int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
  
  /*
  if dest == NULL, the return value specifies the required size of the buffer,
    in 16-bit characters, including the null-terminating character.
  if dest != NULL, the return value specifies the number of 16-bit characters that
    are written to the dest, including the null-terminating character. */
  
  size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
  
  SRes SzArEx_Extract(
      const CSzArEx *db,
      ILookInStream *inStream,
      UInt32 fileIndex,         /* index of file */
      UInt32 *blockIndex,       /* index of solid block */
      Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
      size_t *outBufferSize,    /* buffer size for output buffer */
      size_t *offset,           /* offset of stream for required file in *outBuffer */
      size_t *outSizeProcessed, /* size of file in *outBuffer */
      ISzAlloc *allocMain,
      ISzAlloc *allocTemp);
  
  
  /*
  SzArEx_Open Errors:
  SZ_ERROR_NO_ARCHIVE
  SZ_ERROR_ARCHIVE
  SZ_ERROR_UNSUPPORTED
  SZ_ERROR_MEM
  SZ_ERROR_CRC
  SZ_ERROR_INPUT_EOF
  SZ_ERROR_FAIL
  */
  
  SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);
  
  EXTERN_C_END
  
  #endif
  