7z Format description (2.30 Beta 25)

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

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 = kCreationTime,

0x13 = kLastAccessTime,

0x14 = kLastWriteTime,

0x15 = kWinAttributes,

0x16 = kComment,

0x17 = kEncodedHeader,

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 DecompressionMethod.IDSize

      4:

        0 - IsSimple

        1 - Is not simple

      5:

        0 - No Attributes

        1 - There Are Attributes

      7:

        0 - Last Method in Alternative_Method_List

        1 - There are more alternative methods

    } 

    BYTE DecompressionMethod.ID[DecompressionMethod.IDSize]

    if (!IsSimple)

    {

      UINT64 NumInStreams;

      UINT64 NumOutStreams;

    }

    if (DecompressionMethod[0] != 0)

    {

      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 kCreationTime:   (0x12)

      case kLastAccessTime: (0x13)

      case kLastWriteTime:  (0x14)

        BYTE AllAreDefined

        if (AllAreDefined == 0)

        {

          for(NumFiles)

            BIT TimeDefined

        }

        BYTE External;

        if(External != 0)

          UINT64 DataIndex

        []

        for(Definded Items)

          UINT32 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