mirrors/Sandboxie
mirrors
/
Sandboxie
mirror of https://github.com/sandboxie-plus/Sandboxie.git
1
0
Fork 0
Code Releases Activity
Sandboxie/SandboxiePlus/MiscHelpers/Archive/7z/CPP/7zip/ICoder.h

478 lines
17 KiB
C++
Raw Blame History

// ICoder.h
#ifndef ZIP7_INC_ICODER_H
#define ZIP7_INC_ICODER_H
#include "IStream.h"
Z7_PURE_INTERFACES_BEGIN
#define Z7_IFACE_CONSTR_CODER(i, n) \
Z7_DECL_IFACE_7ZIP(i, 4, n) \
{ Z7_IFACE_COM7_PURE(i) };
#define Z7_IFACEM_ICompressProgressInfo(x) \
x(SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
Z7_IFACE_CONSTR_CODER(ICompressProgressInfo, 0x04)
/*
SetRatioInfo()
(inSize) can be NULL, if unknown
(outSize) can be NULL, if unknown
returns:
S_OK
E_ABORT : Break by user
another error codes
*/
#define Z7_IFACEM_ICompressCoder(x) \
x(Code(ISequentialInStream *inStream, ISequentialOutStream *outStream, \
const UInt64 *inSize, const UInt64 *outSize, \
ICompressProgressInfo *progress))
Z7_IFACE_CONSTR_CODER(ICompressCoder, 0x05)
#define Z7_IFACEM_ICompressCoder2(x) \
x(Code(ISequentialInStream * const *inStreams, const UInt64 *const *inSizes, UInt32 numInStreams, \
ISequentialOutStream *const *outStreams, const UInt64 *const *outSizes, UInt32 numOutStreams, \
ICompressProgressInfo *progress))
Z7_IFACE_CONSTR_CODER(ICompressCoder2, 0x18)
/*
ICompressCoder::Code
ICompressCoder2::Code
returns:
S_OK : OK
S_FALSE : data error (for decoders)
E_OUTOFMEMORY : memory allocation error
E_NOTIMPL : unsupported encoding method (for decoders)
another error code : some error. For example, it can be error code received from inStream or outStream function.
Parameters:
(inStream != NULL)
(outStream != NULL)
if (inSize != NULL)
{
Encoders in 7-Zip ignore (inSize).
Decoder can use (*inSize) to check that stream was decoded correctly.
Some decoders in 7-Zip check it, if (full_decoding mode was set via ICompressSetFinishMode)
}
If it's required to limit the reading from input stream (inStream), it can
be done with ISequentialInStream implementation.
if (outSize != NULL)
{
Encoders in 7-Zip ignore (outSize).
Decoder unpacks no more than (*outSize) bytes.
}
(progress == NULL) is allowed.
Decoding with Code() function
-----------------------------
You can request some interfaces before decoding
- ICompressSetDecoderProperties2
- ICompressSetFinishMode
If you need to decode full stream:
{
1) try to set full_decoding mode with ICompressSetFinishMode::SetFinishMode(1);
2) call the Code() function with specified (inSize) and (outSize), if these sizes are known.
}
If you need to decode only part of stream:
{
1) try to set partial_decoding mode with ICompressSetFinishMode::SetFinishMode(0);
2) Call the Code() function with specified (inSize = NULL) and specified (outSize).
}
Encoding with Code() function
-----------------------------
You can request some interfaces :
- ICompressSetCoderProperties - use it before encoding to set properties
- ICompressWriteCoderProperties - use it before or after encoding to request encoded properties.
ICompressCoder2 is used when (numInStreams != 1 || numOutStreams != 1)
The rules are similar to ICompressCoder rules
*/
namespace NCoderPropID
{
enum EEnum
{
kDefaultProp = 0,
kDictionarySize, // VT_UI4
kUsedMemorySize, // VT_UI4
kOrder, // VT_UI4
kBlockSize, // VT_UI4 or VT_UI8
kPosStateBits, // VT_UI4
kLitContextBits, // VT_UI4
kLitPosBits, // VT_UI4
kNumFastBytes, // VT_UI4
kMatchFinder, // VT_BSTR
kMatchFinderCycles, // VT_UI4
kNumPasses, // VT_UI4
kAlgorithm, // VT_UI4
kNumThreads, // VT_UI4
kEndMarker, // VT_BOOL
kLevel, // VT_UI4
kReduceSize, // VT_UI8 : it's estimated size of largest data stream that will be compressed
// encoder can use this value to reduce dictionary size and allocate data buffers
kExpectedDataSize, // VT_UI8 : for ICompressSetCoderPropertiesOpt :
// it's estimated size of current data stream
// real data size can differ from that size
// encoder can use this value to optimize encoder initialization
kBlockSize2, // VT_UI4 or VT_UI8
kCheckSize, // VT_UI4 : size of digest in bytes
kFilter, // VT_BSTR
kMemUse, // VT_UI8
kAffinity, // VT_UI8
kBranchOffset, // VT_UI4
kHashBits, // VT_UI4
/*
// kHash3Bits, // VT_UI4
// kHash2Bits, // VT_UI4
// kChainBits, // VT_UI4
kChainSize, // VT_UI4
kNativeLevel, // VT_UI4
kFast, // VT_UI4
kMinMatch, // VT_UI4 The minimum slen is 3 and the maximum is 7.
kOverlapLog, // VT_UI4 The minimum ovlog is 0 and the maximum is 9. (default: 6)
kRowMatchFinder, // VT_BOOL
kLdmEnable, // VT_BOOL
// kLdmWindowSizeLog, // VT_UI4
kLdmWindowSize, // VT_UI4
kLdmHashLog, // VT_UI4 The minimum ldmhlog is 6 and the maximum is 26 (default: 20).
kLdmMinMatchLength, // VT_UI4 The minimum ldmslen is 4 and the maximum is 4096 (default: 64).
kLdmBucketSizeLog, // VT_UI4 The minimum ldmblog is 0 and the maximum is 8 (default: 3).
kLdmHashRateLog, // VT_UI4 The default value is wlog - ldmhlog.
kWriteUnpackSizeFlag, // VT_BOOL
kUsePledged, // VT_BOOL
kUseSizeHintPledgedForSmall, // VT_BOOL
kUseSizeHintForEach, // VT_BOOL
kUseSizeHintGlobal, // VT_BOOL
kParamSelectMode, // VT_UI4
// kSearchLog, // VT_UI4 The minimum slog is 1 and the maximum is 26
// kTargetLen, // VT_UI4 The minimum tlen is 0 and the maximum is 999.
*/
k_NUM_DEFINED
};
}
#define Z7_IFACEM_ICompressSetCoderPropertiesOpt(x) \
x(SetCoderPropertiesOpt(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
Z7_IFACE_CONSTR_CODER(ICompressSetCoderPropertiesOpt, 0x1F)
#define Z7_IFACEM_ICompressSetCoderProperties(x) \
x(SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
Z7_IFACE_CONSTR_CODER(ICompressSetCoderProperties, 0x20)
/*
#define Z7_IFACEM_ICompressSetDecoderProperties(x) \
x(SetDecoderProperties(ISequentialInStream *inStream))
Z7_IFACE_CONSTR_CODER(ICompressSetDecoderProperties, 0x21)
*/
#define Z7_IFACEM_ICompressSetDecoderProperties2(x) \
x(SetDecoderProperties2(const Byte *data, UInt32 size))
Z7_IFACE_CONSTR_CODER(ICompressSetDecoderProperties2, 0x22)
/* returns:
S_OK
E_NOTIMP : unsupported properties
E_INVALIDARG : incorrect (or unsupported) properties
E_OUTOFMEMORY : memory allocation error
*/
#define Z7_IFACEM_ICompressWriteCoderProperties(x) \
x(WriteCoderProperties(ISequentialOutStream *outStream))
Z7_IFACE_CONSTR_CODER(ICompressWriteCoderProperties, 0x23)
#define Z7_IFACEM_ICompressGetInStreamProcessedSize(x) \
x(GetInStreamProcessedSize(UInt64 *value))
Z7_IFACE_CONSTR_CODER(ICompressGetInStreamProcessedSize, 0x24)
#define Z7_IFACEM_ICompressSetCoderMt(x) \
x(SetNumberOfThreads(UInt32 numThreads))
Z7_IFACE_CONSTR_CODER(ICompressSetCoderMt, 0x25)
#define Z7_IFACEM_ICompressSetFinishMode(x) \
x(SetFinishMode(UInt32 finishMode))
Z7_IFACE_CONSTR_CODER(ICompressSetFinishMode, 0x26)
/* finishMode:
0 : partial decoding is allowed. It's default mode for ICompressCoder::Code(), if (outSize) is defined.
1 : full decoding. The stream must be finished at the end of decoding. */
#define Z7_IFACEM_ICompressGetInStreamProcessedSize2(x) \
x(GetInStreamProcessedSize2(UInt32 streamIndex, UInt64 *value))
Z7_IFACE_CONSTR_CODER(ICompressGetInStreamProcessedSize2, 0x27)
#define Z7_IFACEM_ICompressSetMemLimit(x) \
x(SetMemLimit(UInt64 memUsage))
Z7_IFACE_CONSTR_CODER(ICompressSetMemLimit, 0x28)
/*
ICompressReadUnusedFromInBuf is supported by ICoder object
call ReadUnusedFromInBuf() after ICoder::Code(inStream, ...).
ICoder::Code(inStream, ...) decodes data, and the ICoder object is allowed
to read from inStream to internal buffers more data than minimal data required for decoding.
So we can call ReadUnusedFromInBuf() from same ICoder object to read unused input
data from the internal buffer.
in ReadUnusedFromInBuf(): the Coder is not allowed to use (ISequentialInStream *inStream) object, that was sent to ICoder::Code().
*/
#define Z7_IFACEM_ICompressReadUnusedFromInBuf(x) \
x(ReadUnusedFromInBuf(void *data, UInt32 size, UInt32 *processedSize))
Z7_IFACE_CONSTR_CODER(ICompressReadUnusedFromInBuf, 0x29)
#define Z7_IFACEM_ICompressGetSubStreamSize(x) \
x(GetSubStreamSize(UInt64 subStream, UInt64 *value))
Z7_IFACE_CONSTR_CODER(ICompressGetSubStreamSize, 0x30)
/* returns:
S_OK : (*value) contains the size or estimated size (can be incorrect size)
S_FALSE : size is undefined
E_NOTIMP : the feature is not implemented
Let's (read_size) is size of data that was already read by ISequentialInStream::Read().
The caller should call GetSubStreamSize() after each Read() and check sizes:
if (start_of_subStream + *value < read_size)
{
// (*value) is correct, and it's allowed to call GetSubStreamSize() for next subStream:
start_of_subStream += *value;
subStream++;
}
*/
#define Z7_IFACEM_ICompressSetInStream(x) \
x(SetInStream(ISequentialInStream *inStream)) \
x(ReleaseInStream())
Z7_IFACE_CONSTR_CODER(ICompressSetInStream, 0x31)
#define Z7_IFACEM_ICompressSetOutStream(x) \
x(SetOutStream(ISequentialOutStream *outStream)) \
x(ReleaseOutStream())
Z7_IFACE_CONSTR_CODER(ICompressSetOutStream, 0x32)
/*
#define Z7_IFACEM_ICompressSetInStreamSize(x) \
x(SetInStreamSize(const UInt64 *inSize)) \
Z7_IFACE_CONSTR_CODER(ICompressSetInStreamSize, 0x33)
*/
#define Z7_IFACEM_ICompressSetOutStreamSize(x) \
x(SetOutStreamSize(const UInt64 *outSize))
Z7_IFACE_CONSTR_CODER(ICompressSetOutStreamSize, 0x34)
/* That function initializes decoder structures.
Call this function only for stream version of decoder.
if (outSize == NULL), then output size is unknown
if (outSize != NULL), then the decoder must stop decoding after (*outSize) bytes. */
#define Z7_IFACEM_ICompressSetBufSize(x) \
x(SetInBufSize(UInt32 streamIndex, UInt32 size)) \
x(SetOutBufSize(UInt32 streamIndex, UInt32 size))
Z7_IFACE_CONSTR_CODER(ICompressSetBufSize, 0x35)
#define Z7_IFACEM_ICompressInitEncoder(x) \
x(InitEncoder())
Z7_IFACE_CONSTR_CODER(ICompressInitEncoder, 0x36)
/* That function initializes encoder structures.
Call this function only for stream version of encoder. */
#define Z7_IFACEM_ICompressSetInStream2(x) \
x(SetInStream2(UInt32 streamIndex, ISequentialInStream *inStream)) \
x(ReleaseInStream2(UInt32 streamIndex))
Z7_IFACE_CONSTR_CODER(ICompressSetInStream2, 0x37)
/*
#define Z7_IFACEM_ICompressSetOutStream2(x) \
x(SetOutStream2(UInt32 streamIndex, ISequentialOutStream *outStream))
x(ReleaseOutStream2(UInt32 streamIndex))
Z7_IFACE_CONSTR_CODER(ICompressSetOutStream2, 0x38)
#define Z7_IFACEM_ICompressSetInStreamSize2(x) \
x(SetInStreamSize2(UInt32 streamIndex, const UInt64 *inSize))
Z7_IFACE_CONSTR_CODER(ICompressSetInStreamSize2, 0x39)
*/
/*
#define Z7_IFACEM_ICompressInSubStreams(x) \
x(GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream))
Z7_IFACE_CONSTR_CODER(ICompressInSubStreams, 0x3A)
#define Z7_IFACEM_ICompressOutSubStreams(x) \
x(GetNextOutSubStream(UInt64 *streamIndexRes, ISequentialOutStream **stream))
Z7_IFACE_CONSTR_CODER(ICompressOutSubStreams, 0x3B)
*/
/*
ICompressFilter
Filter(Byte *data, UInt32 size)
(size)
converts as most as possible bytes required for fast processing.
Some filters have (smallest_fast_block).
For example, (smallest_fast_block == 16) for AES CBC/CTR filters.
If data stream is not finished, caller must call Filter() for larger block:
where (size >= smallest_fast_block).
if (size >= smallest_fast_block)
{
The filter can leave some bytes at the end of data without conversion:
if there are data alignment reasons or speed reasons.
The caller can read additional data from stream and call Filter() again.
}
If data stream was finished, caller can call Filter() for (size < smallest_fast_block)
(data) parameter:
Some filters require alignment for any Filter() call:
1) (stream_offset % alignment_size) == (data % alignment_size)
2) (alignment_size == 2^N)
where (stream_offset) - is the number of bytes that were already filtered before.
The callers of Filter() are required to meet these requirements.
(alignment_size) can be different:
16 : for AES filters
4 or 2 : for some branch convert filters
1 : for another filters
(alignment_size >= 16) is enough for all current filters of 7-Zip.
But the caller can use larger (alignment_size).
Recommended alignment for (data) of Filter() call is (alignment_size == 64).
Also it's recommended to use aligned value for (size):
(size % alignment_size == 0),
if it's not last call of Filter() for current stream.
returns: (outSize):
if (outSize == 0) : Filter have not converted anything.
So the caller can stop processing, if data stream was finished.
if (outSize <= size) : Filter have converted outSize bytes
if (outSize > size) : Filter have not converted anything.
and it needs at least outSize bytes to convert one block
(it's for crypto block algorithms).
*/
#define Z7_IFACEM_ICompressFilter(x) \
x(Init()) \
x##2(UInt32, Filter(Byte *data, UInt32 size))
Z7_IFACE_CONSTR_CODER(ICompressFilter, 0x40)
#define Z7_IFACEM_ICompressCodecsInfo(x) \
x(GetNumMethods(UInt32 *numMethods)) \
x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
x(CreateDecoder(UInt32 index, const GUID *iid, void* *coder)) \
x(CreateEncoder(UInt32 index, const GUID *iid, void* *coder))
Z7_IFACE_CONSTR_CODER(ICompressCodecsInfo, 0x60)
#define Z7_IFACEM_ISetCompressCodecsInfo(x) \
x(SetCompressCodecsInfo(ICompressCodecsInfo *compressCodecsInfo))
Z7_IFACE_CONSTR_CODER(ISetCompressCodecsInfo, 0x61)
#define Z7_IFACEM_ICryptoProperties(x) \
x(SetKey(const Byte *data, UInt32 size)) \
x(SetInitVector(const Byte *data, UInt32 size))
Z7_IFACE_CONSTR_CODER(ICryptoProperties, 0x80)
/*
x(ResetSalt())
Z7_IFACE_CONSTR_CODER(ICryptoResetSalt, 0x88)
*/
#define Z7_IFACEM_ICryptoResetInitVector(x) \
x(ResetInitVector())
Z7_IFACE_CONSTR_CODER(ICryptoResetInitVector, 0x8C)
/* Call ResetInitVector() only for encoding.
Call ResetInitVector() before encoding and before WriteCoderProperties().
Crypto encoder can create random IV in that function. */
#define Z7_IFACEM_ICryptoSetPassword(x) \
x(CryptoSetPassword(const Byte *data, UInt32 size))
Z7_IFACE_CONSTR_CODER(ICryptoSetPassword, 0x90)
#define Z7_IFACEM_ICryptoSetCRC(x) \
x(CryptoSetCRC(UInt32 crc))
Z7_IFACE_CONSTR_CODER(ICryptoSetCRC, 0xA0)
namespace NMethodPropID
{
enum EEnum
{
kID,
kName,
kDecoder,
kEncoder,
kPackStreams,
kUnpackStreams,
kDescription,
kDecoderIsAssigned,
kEncoderIsAssigned,
kDigestSize,
kIsFilter
};
}
namespace NModuleInterfaceType
{
/*
virtual destructor in IUnknown:
- no : 7-Zip (Windows)
- no : 7-Zip (Linux) (v23) in default mode
- yes : p7zip
- yes : 7-Zip (Linux) before v23
- yes : 7-Zip (Linux) (v23), if Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN is defined
*/
const UInt32 k_IUnknown_VirtDestructor_No = 0;
const UInt32 k_IUnknown_VirtDestructor_Yes = 1;
const UInt32 k_IUnknown_VirtDestructor_ThisModule =
#if !defined(_WIN32) && defined(Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN)
k_IUnknown_VirtDestructor_Yes;
#else
k_IUnknown_VirtDestructor_No;
#endif
}
namespace NModulePropID
{
enum EEnum
{
kInterfaceType, // VT_UI4
kVersion // VT_UI4
};
}
#define Z7_IFACEM_IHasher(x) \
x##2(void, Init()) \
x##2(void, Update(const void *data, UInt32 size)) \
x##2(void, Final(Byte *digest)) \
x##2(UInt32, GetDigestSize())
Z7_IFACE_CONSTR_CODER(IHasher, 0xC0)
#define Z7_IFACEM_IHashers(x) \
x##2(UInt32, GetNumHashers()) \
x(GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)) \
x(CreateHasher(UInt32 index, IHasher **hasher))
Z7_IFACE_CONSTR_CODER(IHashers, 0xC1)
extern "C"
{
typedef HRESULT (WINAPI *Func_GetNumberOfMethods)(UInt32 *numMethods);
typedef HRESULT (WINAPI *Func_GetMethodProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
typedef HRESULT (WINAPI *Func_CreateDecoder)(UInt32 index, const GUID *iid, void **outObject);
typedef HRESULT (WINAPI *Func_CreateEncoder)(UInt32 index, const GUID *iid, void **outObject);
typedef HRESULT (WINAPI *Func_GetHashers)(IHashers **hashers);
typedef HRESULT (WINAPI *Func_SetCodecs)(ICompressCodecsInfo *compressCodecsInfo);
typedef HRESULT (WINAPI *Func_GetModuleProp)(PROPID propID, PROPVARIANT *value);
}
Z7_PURE_INTERFACES_END
#endif
View Git Blame Copy Permalink