Expand menu
7z Format description (4.59)

----------------------------



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 = 2

  };



  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)

          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