7z Format description (18.06) | |
---------------------------- | |
This file contains description of 7z archive format. | |
7z archive can contain files compressed with any method. | |
See "Methods.txt" for description for defined compressing methods. | |
Format structure Overview | |
------------------------- | |
Some fields can be optional. | |
Archive structure | |
~~~~~~~~~~~~~~~~~ | |
SignatureHeader | |
[PackedStreams] | |
[PackedStreamsForHeaders] | |
[ | |
Header | |
or | |
{ | |
Packed Header | |
HeaderInfo | |
} | |
] | |
Header structure | |
~~~~~~~~~~~~~~~~ | |
{ | |
ArchiveProperties | |
AdditionalStreams | |
{ | |
PackInfo | |
{ | |
PackPos | |
NumPackStreams | |
Sizes[NumPackStreams] | |
CRCs[NumPackStreams] | |
} | |
CodersInfo | |
{ | |
NumFolders | |
Folders[NumFolders] | |
{ | |
NumCoders | |
CodersInfo[NumCoders] | |
{ | |
ID | |
NumInStreams; | |
NumOutStreams; | |
PropertiesSize | |
Properties[PropertiesSize] | |
} | |
NumBindPairs | |
BindPairsInfo[NumBindPairs] | |
{ | |
InIndex; | |
OutIndex; | |
} | |
PackedIndices | |
} | |
UnPackSize[Folders][Folders.NumOutstreams] | |
CRCs[NumFolders] | |
} | |
SubStreamsInfo | |
{ | |
NumUnPackStreamsInFolders[NumFolders]; | |
UnPackSizes[] | |
CRCs[] | |
} | |
} | |
MainStreamsInfo | |
{ | |
(Same as in AdditionalStreams) | |
} | |
FilesInfo | |
{ | |
NumFiles | |
Properties[] | |
{ | |
ID | |
Size | |
Data | |
} | |
} | |
} | |
HeaderInfo structure | |
~~~~~~~~~~~~~~~~~~~~ | |
{ | |
(Same as in AdditionalStreams) | |
} | |
Notes about Notation and encoding | |
--------------------------------- | |
7z uses little endian encoding. | |
7z archive format has optional headers that are marked as | |
[] | |
Header | |
[] | |
REAL_UINT64 means real UINT64. | |
UINT64 means real UINT64 encoded with the following scheme: | |
Size of encoding sequence depends from first byte: | |
First_Byte Extra_Bytes Value | |
(binary) | |
0xxxxxxx : ( xxxxxxx ) | |
10xxxxxx BYTE y[1] : ( xxxxxx << (8 * 1)) + y | |
110xxxxx BYTE y[2] : ( xxxxx << (8 * 2)) + y | |
... | |
1111110x BYTE y[6] : ( x << (8 * 6)) + y | |
11111110 BYTE y[7] : y | |
11111111 BYTE y[8] : y | |
Property IDs | |
------------ | |
0x00 = kEnd | |
0x01 = kHeader | |
0x02 = kArchiveProperties | |
0x03 = kAdditionalStreamsInfo | |
0x04 = kMainStreamsInfo | |
0x05 = kFilesInfo | |
0x06 = kPackInfo | |
0x07 = kUnPackInfo | |
0x08 = kSubStreamsInfo | |
0x09 = kSize | |
0x0A = kCRC | |
0x0B = kFolder | |
0x0C = kCodersUnPackSize | |
0x0D = kNumUnPackStream | |
0x0E = kEmptyStream | |
0x0F = kEmptyFile | |
0x10 = kAnti | |
0x11 = kName | |
0x12 = kCTime | |
0x13 = kATime | |
0x14 = kMTime | |
0x15 = kWinAttributes | |
0x16 = kComment | |
0x17 = kEncodedHeader | |
0x18 = kStartPos | |
0x19 = kDummy | |
7z format headers | |
----------------- | |
SignatureHeader | |
~~~~~~~~~~~~~~~ | |
BYTE kSignature[6] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C}; | |
ArchiveVersion | |
{ | |
BYTE Major; // now = 0 | |
BYTE Minor; // now = 4 | |
}; | |
UINT32 StartHeaderCRC; | |
StartHeader | |
{ | |
REAL_UINT64 NextHeaderOffset | |
REAL_UINT64 NextHeaderSize | |
UINT32 NextHeaderCRC | |
} | |
........................... | |
ArchiveProperties | |
~~~~~~~~~~~~~~~~~ | |
BYTE NID::kArchiveProperties (0x02) | |
for (;;) | |
{ | |
BYTE PropertyType; | |
if (aType == 0) | |
break; | |
UINT64 PropertySize; | |
BYTE PropertyData[PropertySize]; | |
} | |
Digests (NumStreams) | |
~~~~~~~~~~~~~~~~~~~~~ | |
BYTE AllAreDefined | |
if (AllAreDefined == 0) | |
{ | |
for(NumStreams) | |
BIT Defined | |
} | |
UINT32 CRCs[NumDefined] | |
PackInfo | |
~~~~~~~~~~~~ | |
BYTE NID::kPackInfo (0x06) | |
UINT64 PackPos | |
UINT64 NumPackStreams | |
[] | |
BYTE NID::kSize (0x09) | |
UINT64 PackSizes[NumPackStreams] | |
[] | |
[] | |
BYTE NID::kCRC (0x0A) | |
PackStreamDigests[NumPackStreams] | |
[] | |
BYTE NID::kEnd | |
Folder | |
~~~~~~ | |
UINT64 NumCoders; | |
for (NumCoders) | |
{ | |
BYTE | |
{ | |
0:3 CodecIdSize | |
4: Is Complex Coder | |
5: There Are Attributes | |
6: Reserved | |
7: There are more alternative methods. (Not used anymore, must be 0). | |
} | |
BYTE CodecId[CodecIdSize] | |
if (Is Complex Coder) | |
{ | |
UINT64 NumInStreams; | |
UINT64 NumOutStreams; | |
} | |
if (There Are Attributes) | |
{ | |
UINT64 PropertiesSize | |
BYTE Properties[PropertiesSize] | |
} | |
} | |
NumBindPairs = NumOutStreamsTotal - 1; | |
for (NumBindPairs) | |
{ | |
UINT64 InIndex; | |
UINT64 OutIndex; | |
} | |
NumPackedStreams = NumInStreamsTotal - NumBindPairs; | |
if (NumPackedStreams > 1) | |
for(NumPackedStreams) | |
{ | |
UINT64 Index; | |
}; | |
Coders Info | |
~~~~~~~~~~~ | |
BYTE NID::kUnPackInfo (0x07) | |
BYTE NID::kFolder (0x0B) | |
UINT64 NumFolders | |
BYTE External | |
switch(External) | |
{ | |
case 0: | |
Folders[NumFolders] | |
case 1: | |
UINT64 DataStreamIndex | |
} | |
BYTE ID::kCodersUnPackSize (0x0C) | |
for(Folders) | |
for(Folder.NumOutStreams) | |
UINT64 UnPackSize; | |
[] | |
BYTE NID::kCRC (0x0A) | |
UnPackDigests[NumFolders] | |
[] | |
BYTE NID::kEnd | |
SubStreams Info | |
~~~~~~~~~~~~~~ | |
BYTE NID::kSubStreamsInfo; (0x08) | |
[] | |
BYTE NID::kNumUnPackStream; (0x0D) | |
UINT64 NumUnPackStreamsInFolders[NumFolders]; | |
[] | |
[] | |
BYTE NID::kSize (0x09) | |
UINT64 UnPackSizes[] | |
[] | |
[] | |
BYTE NID::kCRC (0x0A) | |
Digests[Number of streams with unknown CRC] | |
[] | |
BYTE NID::kEnd | |
Streams Info | |
~~~~~~~~~~~~ | |
[] | |
PackInfo | |
[] | |
[] | |
CodersInfo | |
[] | |
[] | |
SubStreamsInfo | |
[] | |
BYTE NID::kEnd | |
FilesInfo | |
~~~~~~~~~ | |
BYTE NID::kFilesInfo; (0x05) | |
UINT64 NumFiles | |
for (;;) | |
{ | |
BYTE PropertyType; | |
if (aType == 0) | |
break; | |
UINT64 Size; | |
switch(PropertyType) | |
{ | |
kEmptyStream: (0x0E) | |
for(NumFiles) | |
BIT IsEmptyStream | |
kEmptyFile: (0x0F) | |
for(EmptyStreams) | |
BIT IsEmptyFile | |
kAnti: (0x10) | |
for(EmptyStreams) | |
BIT IsAntiFile | |
case kCTime: (0x12) | |
case kATime: (0x13) | |
case kMTime: (0x14) | |
BYTE AllAreDefined | |
if (AllAreDefined == 0) | |
{ | |
for(NumFiles) | |
BIT TimeDefined | |
} | |
BYTE External; | |
if(External != 0) | |
UINT64 DataIndex | |
[] | |
for(Definded Items) | |
REAL_UINT64 Time | |
[] | |
kNames: (0x11) | |
BYTE External; | |
if(External != 0) | |
UINT64 DataIndex | |
[] | |
for(Files) | |
{ | |
wchar_t Names[NameSize]; | |
wchar_t 0; | |
} | |
[] | |
kAttributes: (0x15) | |
BYTE AllAreDefined | |
if (AllAreDefined == 0) | |
{ | |
for(NumFiles) | |
BIT AttributesAreDefined | |
} | |
BYTE External; | |
if(External != 0) | |
UINT64 DataIndex | |
[] | |
for(Definded Attributes) | |
UINT32 Attributes | |
[] | |
} | |
} | |
Header | |
~~~~~~ | |
BYTE NID::kHeader (0x01) | |
[] | |
ArchiveProperties | |
[] | |
[] | |
BYTE NID::kAdditionalStreamsInfo; (0x03) | |
StreamsInfo | |
[] | |
[] | |
BYTE NID::kMainStreamsInfo; (0x04) | |
StreamsInfo | |
[] | |
[] | |
FilesInfo | |
[] | |
BYTE NID::kEnd | |
HeaderInfo | |
~~~~~~~~~~ | |
[] | |
BYTE NID::kEncodedHeader; (0x17) | |
StreamsInfo for Encoded Header | |
[] | |
--- | |
End of document |