/* $Id: udf.h $ */
/** @file
 * IPRT, Universal Disk Format (UDF).
 */

/*
 * Copyright (C) 2017-2025 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */

#ifndef IPRT_INCLUDED_formats_udf_h
#define IPRT_INCLUDED_formats_udf_h
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include <iprt/types.h>
#include <iprt/assertcompile.h>
#include <iprt/formats/iso9660.h>


/** @defgroup grp_rt_formats_udf    Universal Disk Format (UDF) structures and definitions
 * @ingroup grp_rt_formats
 *
 * References:
 *  - https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-167.pdf
 *  - http://www.osta.org/specs/pdf/udf260.pdf
 *  - http://wiki.osdev.org/UDF
 *  - https://sites.google.com/site/udfintro/
 *
 * @{
 */

/**
 * UDF d-character string (@ecma167{1,7.2.12,25}).
 *
 * This is mainly to mark what's d-strings and what's not.
 */
typedef char UDFDSTRING;
/** Pointer to an UDF dstring. */
typedef UDFDSTRING *PUDFDSTRING;
/** Pointer to a const UDF dstring. */
typedef UDFDSTRING const *PCUDFDSTRING;

/**
 * UDF extent allocation descriptor (AD) (@ecma167{3,7.1,42}).
 */
typedef struct UDFEXTENTAD
{
    /** Extent length in bytes. */
    uint32_t        cb;
    /** Extent offset (logical sector number).
     * If @a cb is zero, this is also zero. */
    uint32_t        off;
} UDFEXTENTAD;
AssertCompileSize(UDFEXTENTAD, 8);
/** Pointer to an UDF extent descriptor. */
typedef UDFEXTENTAD *PUDFEXTENTAD;
/** Pointer to a const UDF extent descriptor. */
typedef UDFEXTENTAD const *PCUDFEXTENTAD;


/**
 * UDF logical block address (@ecma167{4,7.1,73}).
 */
#pragma pack(2)
typedef struct UDFLBADDR
{
    /** Logical block number, relative to the start of the given partition. */
    uint32_t        off;
    /** Partition reference number. */
    uint16_t        uPartitionNo;
} UDFLBADDR;
#pragma pack()
AssertCompileSize(UDFLBADDR, 6);
/** Pointer to an UDF logical block address. */
typedef UDFLBADDR *PUDFLBADDR;
/** Pointer to a const UDF logical block address. */
typedef UDFLBADDR const *PCUDFLBADDR;


/** @name UDF_AD_TYPE_XXX - Allocation descriptor types.
 *
 * Used by UDFSHORTAD::uType, UDFLONGAD::uType and UDFEXTAD::uType.
 *
 * See @ecma167{4,14.14.1.1,116}.
 *
 * @{ */
/** Recorded and allocated.
 * Also used for zero length descriptors. */
#define UDF_AD_TYPE_RECORDED_AND_ALLOCATED          0
/** Allocated but not recorded. */
#define UDF_AD_TYPE_ONLY_ALLOCATED                  1
/** Not recorded nor allocated. */
#define UDF_AD_TYPE_FREE                            2
/** Location of the an UDFALLOCATIONEXTENTDESC.
 * This is used when the ICB doesn't contain suffient room for all the
 * allocation descriptors. */
#define UDF_AD_TYPE_NEXT                            3
/** @} */

/**
 * UDF short allocation descriptor (@ecma167{4,14.14.1,116}).
 */
typedef struct UDFSHORTAD
{
#ifdef RT_BIG_ENDIAN
    /** Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
    /** Extent length in bytes, top 2 bits . */
    uint32_t        cb : 30;
#else
    /** Extent length in bytes. */
    uint32_t        cb : 30;
    /** Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
#endif
    /** Extent offset (logical sector number). */
    uint32_t        off;
} UDFSHORTAD;
AssertCompileSize(UDFSHORTAD, 8);
/** Pointer to an UDF short allocation descriptor. */
typedef UDFSHORTAD *PUDFSHORTAD;
/** Pointer to a const UDF short allocation descriptor. */
typedef UDFSHORTAD const *PCUDFSHORTAD;

/**
 * UDF long allocation descriptor (@ecma167{4,14.14.2,116}).
 */
#pragma pack(2)
typedef struct UDFLONGAD
{
#ifdef RT_BIG_ENDIAN
    /** Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
    /** Extent length in bytes, top 2 bits . */
    uint32_t        cb : 30;
#else
    /** Extent length in bytes. */
    uint32_t        cb : 30;
    /** Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
#endif
    /** Extent location. */
    UDFLBADDR       Location;
    /** Implementation use area. */
    union
    {
        /** Generic view. */
        uint8_t     ab[6];
        /** Used in FIDs.
         * See @udf260{2.3.10.1,66}, @udf260{2.3.4.3,58}.
         */
        struct
        {
            /** Flags (UDF_AD_IMP_USE_FLAGS_XXX).   */
            uint16_t    fFlags;
            /** Unique ID. */
            uint32_t    idUnique;
        } Fid;
    } ImplementationUse;
} UDFLONGAD;
#pragma pack()
AssertCompileSize(UDFLONGAD, 16);
/** Pointer to an UDF long allocation descriptor. */
typedef UDFLONGAD *PUDFLONGAD;
/** Pointer to a const UDF long allocation descriptor. */
typedef UDFLONGAD const *PCUDFLONGAD;

/** @name UDF_AD_IMP_USE_FLAGS_XXX - UDFLONGAD::ImplementationUse::Fid::fFlags values
 * See @udf260{2.3.10.1,66}.
 * @{ */
/** Set if erased and the extend is of the type UDF_AD_TYPE_ONLY_ALLOCATED. */
#define UDF_AD_IMP_USE_FLAGS_ERASED         UINT16_C(0x0001)
/** Valid mask.   */
#define UDF_AD_IMP_USE_FLAGS_VALID_MASK     UINT16_C(0x0001)
/** @} */

/**
 * UDF extended allocation descriptor (@ecma167{4,14.14.3,117}).
 */
typedef struct UDFEXTAD
{
#ifdef RT_BIG_ENDIAN
    /** 0x00: Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
    /** 0x00: Extent length in bytes, top 2 bits . */
    uint32_t        cb : 30;
    /** 0x04: Reserved, MBZ. */
    uint32_t        uReserved : 2;
    /** 0x04: Number of bytes recorded. */
    uint32_t        cbRecorded : 30;
#else
    /** 0x00: Extent length in bytes. */
    uint32_t        cb : 30;
    /** 0x00: Extent type (UDF_AD_TYPE_XXX). */
    uint32_t        uType : 2;
    /** 0x04: Number of bytes recorded. */
    uint32_t        cbRecorded : 30;
    /** 0x04: Reserved, MBZ. */
    uint32_t        uReserved : 2;
#endif
    /** 0x08: Number of bytes of information (from first byte). */
    uint32_t        cbInformation;
    /** 0x0c: Extent location. */
    UDFLBADDR       Location;
    /** 0x12: Implementation use area. */
    uint8_t         abImplementationUse[2];
} UDFEXTAD;
AssertCompileSize(UDFEXTAD, 20);
/** Pointer to an UDF extended allocation descriptor. */
typedef UDFEXTAD *PUDFEXTAD;
/** Pointer to a const UDF extended allocation descriptor. */
typedef UDFEXTAD const *PCUDFEXTAD;


/**
 * UDF timestamp (@ecma167{1,7.3,25}, @udf260{2.1.4,19}).
 */
typedef struct UDFTIMESTAMP
{
#ifdef RT_BIG_ENDIAN
    /** 0x00: Type (UDFTIMESTAMP_T_XXX). */
    RT_GCC_EXTENSION uint16_t   fType : 4;
    /** 0x00: Time zone offset in minutes.
     * For EST this will be -300, whereas for CET it will be 60. */
    RT_GCC_EXTENSION int16_t    offUtcInMin : 12;
#else
    /** 0x00: Time zone offset in minutes.
     * For EST this will be -300, whereas for CET it will be 60. */
    RT_GCC_EXTENSION int16_t    offUtcInMin : 12;
    /** 0x00: Type (UDFTIMESTAMP_T_XXX). */
    RT_GCC_EXTENSION uint16_t   fType : 4;
#endif
    /** 0x02: The year. */
    int16_t         iYear;
    /** 0x04: Month of year (1-12). */
    uint8_t         uMonth;
    /** 0x05: Day of month (1-31). */
    uint8_t         uDay;
    /** 0x06: Hour of day (0-23). */
    uint8_t         uHour;
    /** 0x07: Minute of hour (0-59). */
    uint8_t         uMinute;
    /** 0x08: Second of minute (0-60 if type 2, otherwise 0-59). */
    uint8_t         uSecond;
    /** 0x09: Number of Centiseconds (0-99). */
    uint8_t         cCentiseconds;
    /** 0x0a: Number of hundreds of microseconds (0-99).  Unit is 100us. */
    uint8_t         cHundredsOfMicroseconds;
    /** 0x0b: Number of microseconds (0-99). */
    uint8_t         cMicroseconds;
} UDFTIMESTAMP;
AssertCompileSize(UDFTIMESTAMP, 12);
/** Pointer to an UDF timestamp. */
typedef UDFTIMESTAMP *PUDFTIMESTAMP;
/** Pointer to a const UDF timestamp. */
typedef UDFTIMESTAMP const *PCUDFTIMESTAMP;

/** @name UDFTIMESTAMP_T_XXX
 * @{ */
/** Local time. */
#define UDFTIMESTAMP_T_LOCAL                1
/** @} */

/** No time zone specified. */
#define UDFTIMESTAMP_NO_TIME_ZONE           (-2047)


/**
 * UDF character set specficiation (@ecma167{1,7.2.1,21}, @udf260{2.1.2,18}).
 */
typedef struct UDFCHARSPEC
{
    /** The character set type (UDF_CHAR_SET_TYPE_XXX) */
    uint8_t     uType;
    /** Character set information. */
    uint8_t     abInfo[63];
} UDFCHARSPEC;
AssertCompileSize(UDFCHARSPEC, 64);
/** Pointer to UDF character set specification. */
typedef UDFCHARSPEC *PUDFCHARSPEC;
/** Pointer to const UDF character set specification. */
typedef UDFCHARSPEC const *PCUDFCHARSPEC;

/** @name UDF_CHAR_SET_TYPE_XXX - Character set types.
 * @{ */
/** CS0: By agreement between the medium producer and consumer.
 * See UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE. */
#define UDF_CHAR_SET_TYPE_BY_AGREEMENT  UINT8_C(0x00)
/** CS1: ASCII (ECMA-6) with all or part of the specified graphic characters. */
#define UDF_CHAR_SET_TYPE_ASCII         UINT8_C(0x01)
/** CS5: Latin-1 (ECMA-94) with all graphical characters. */
#define UDF_CHAR_SET_TYPE_LATIN_1       UINT8_C(0x05)
/* there are more defined here, but they are mostly useless, since UDF only uses CS0. */

/** The CS0 definition used by the UDF specification. */
#define UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE        UDF_CHAR_SET_TYPE_BY_AGREEMENT
/** String to put in the UDFCHARSEPC::abInfo field for UDF CS0. */
#define UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO   "OSTA Compressed Unicode"
/** @} */


/**
 * UDF entity identifier (@ecma167{1,7.4,26}, @udf260{2.1.5,20}).
 */
typedef struct UDFENTITYID
{
    /** 0x00: Flags (UDFENTITYID_FLAGS_XXX). */
    uint8_t         fFlags;
    /** 0x01: Identifier string (see UDF_ENTITY_ID_XXX). */
    char            achIdentifier[23];
    /** 0x18: Identifier suffix. */
    union
    {
        /** Domain ID suffix. */
        struct
        {
            uint16_t    uUdfRevision;
            uint8_t     fDomain;
            uint8_t     abReserved[5];
        } Domain;

        /** UDF ID suffix. */
        struct
        {
            uint16_t    uUdfRevision;
            uint8_t     bOsClass;
            uint8_t     idOS;
            uint8_t     abReserved[4];
        } Udf;


        /** Implementation ID suffix. */
        struct
        {
            uint8_t     bOsClass;
            uint8_t     idOS;
            uint8_t     achImplUse[6];
        } Implementation;

        /** Application ID suffix / generic. */
        uint8_t     abApplication[8];
    } Suffix;
} UDFENTITYID;
AssertCompileSize(UDFENTITYID, 32);
/** Pointer to UDF entity identifier. */
typedef UDFENTITYID *PUDFENTITYID;
/** Pointer to const UDF entity identifier. */
typedef UDFENTITYID const *PCUDFENTITYID;

/** @name UDF_ENTITY_ID_XXX - UDF identifier strings
 *
 * See @udf260{2.1.5.2,21}.
 *
 * @{ */
/** Implementation use volume descriptor, implementation ID field.
 * UDF ID suffix. */
#define UDF_ENTITY_ID_IUVD_IMPLEMENTATION       "*UDF LV Info"

/** Partition descriptor, partition contents field, set to indicate UDF
 * (ECMA-167 2nd edition). Application ID suffix. */
#define UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF_2   "+NSR02"
/** Partition descriptor, partition contents field, set to indicate UDF
 * (ECMA-167 3rd edition). Application ID suffix. */
#define UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF_3   "+NSR03"
/** Partition descriptor, partition contents field, set to indicate ISO-9660
 * (ECMA-119). Application ID suffix. */
#define UDF_ENTITY_ID_PD_PARTITION_CONTENTS_ISO9660 "+CD001"
/** Partition descriptor, partition contents field, set to indicate ECMA-168.
 * Application ID suffix. */
#define UDF_ENTITY_ID_PD_PARTITION_CONTENTS_CDW     "+CDW02"
/** Partition descriptor, partition contents field, set to indicate FAT
 * (ECMA-107). Application ID suffix. */
#define UDF_ENTITY_ID_PD_PARTITION_CONTENTS_FAT     "+FDC01"

/** Logical volume descriptor, domain ID field.
 * Domain ID suffix. */
#define UDF_ENTITY_ID_LVD_DOMAIN                "*OSTA UDF Compliant"

/** File set descriptor, domain ID field.
 * Domain ID suffix. */
#define UDF_ENTITY_FSD_LVD_DOMAIN               "*OSTA UDF Compliant"

/** UDF implementation use extended attribute, implementation ID field, set
 * to free EA space.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_FREE_EA_SPACE        "*UDF FreeEASpace"
/** UDF implementation use extended attribute, implementation ID field, set
 * to DVD copyright management information.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_DVD_CGMS_INFO        "*UDF DVD CGMS Info"
/** UDF implementation use extended attribute, implementation ID field, set
 * to OS/2 extended attribute length.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_OS2_EA_LENGTH        "*UDF OS/2 EALength"
/** UDF implementation use extended attribute, implementation ID field, set
 * to Machintosh OS volume information.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_MAC_VOLUME_INFO      "*UDF Mac VolumeInfo"
/** UDF implementation use extended attribute, implementation ID field, set
 * to Machintosh Finder Info.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_MAC_FINDER_INFO      "*UDF Mac FinderInfo"
/** UDF implementation use extended attribute, implementation ID field, set
 * to OS/400 extended directory information.  UDF ID suffix. */
#define UDF_ENTITY_ID_IUEA_OS400_DIR_INFO       "*UDF OS/400 DirInfo"

/** UDF application use extended attribute, application ID field, set
 * to free application use EA space.  UDF ID suffix. */
#define UDF_ENTITY_ID_AUEA_FREE_EA_SPACE        "*UDF FreeAppEASpace"

/** Virtual partition map, partition type field.
 * UDF ID suffix. */
#define UDF_ENTITY_ID_VPM_PARTITION_TYPE        "*UDF Virtual Partition"

/** Sparable partition map, partition type field.
 * UDF ID suffix. */
#define UDF_ENTITY_ID_SPM_PARTITION_TYPE        "*UDF Sparable Partition"

/** Metadata partition map, partition type field.
 * UDF ID suffix. */
#define UDF_ENTITY_ID_MPM_PARTITION_TYPE        "*UDF Metadata Partition"

/** Sparing table, sparing identifier field.
 * UDF ID suffix. */
#define UDF_ENTITY_ID_ST_SPARING                "*UDF Sparting Table"

/** @} */


/**
 * UDF descriptor tag (@ecma167{3,7.2,42}, @udf260{2.2.1,26}).
 */
typedef struct UDFTAG
{
    /** 0x00: Tag identifier (UDF_TAG_ID_XXX). */
    uint16_t        idTag;
    /** 0x02: Descriptor version. */
    uint16_t        uVersion;
    /** 0x04: Tag checksum.
     * Sum of each byte in the structure with this field as zero.  */
    uint8_t         uChecksum;
    /** 0x05: Reserved, MBZ. */
    uint8_t         bReserved;
    /** 0x06: Tag serial number. */
    uint16_t        uTagSerialNo;
    /** 0x08: Descriptor CRC. */
    uint16_t        uDescriptorCrc;
    /** 0x0a: Descriptor CRC length. */
    uint16_t        cbDescriptorCrc;
    /** 0x0c: The tag location (logical sector number). */
    uint32_t        offTag;
} UDFTAG;
AssertCompileSize(UDFTAG, 16);
/** Pointer to an UDF descriptor tag. */
typedef UDFTAG *PUDFTAG;
/** Pointer to a const UDF descriptor tag. */
typedef UDFTAG const *PCUDFTAG;

/** @name UDF_TAG_ID_XXX - UDF descriptor tag IDs.
 * @{ */
#define UDF_TAG_ID_PRIMARY_VOL_DESC                 UINT16_C(0x0001) /**< See UDFPRIMARYVOLUMEDESC */
#define UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR           UINT16_C(0x0002) /**< See UDFANCHORVOLUMEDESCPTR */
#define UDF_TAG_ID_VOLUME_DESC_PTR                  UINT16_C(0x0003) /**< See UDFVOLUMEDESCPTR */
#define UDF_TAG_ID_IMPLEMENTATION_USE_VOLUME_DESC   UINT16_C(0x0004) /**< See UDFIMPLEMENTATIONUSEVOLUMEDESC */
#define UDF_TAG_ID_PARTITION_DESC                   UINT16_C(0x0005) /**< See UDFPARTITIONDESC */
#define UDF_TAG_ID_LOGICAL_VOLUME_DESC              UINT16_C(0x0006) /**< See UDFLOGICALVOLUMEDESC */
#define UDF_TAG_ID_UNALLOCATED_SPACE_DESC           UINT16_C(0x0007) /**< See UDFUNALLOCATEDSPACEDESC */
#define UDF_TAG_ID_TERMINATING_DESC                 UINT16_C(0x0008) /**< See UDFTERMINATINGDESC */
#define UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC    UINT16_C(0x0009) /**< See UDFLOGICALVOLINTEGRITYDESC */
#define UDF_TAG_ID_FILE_SET_DESC                    UINT16_C(0x0100) /**< See UDFFILESETDESC */
#define UDF_TAG_ID_FILE_ID_DESC                     UINT16_C(0x0101) /**< See UDFFILEIDDESC */
#define UDF_TAG_ID_ALLOCATION_EXTENT_DESC           UINT16_C(0x0102) /**< See UDFALLOCATIONEXTENTDESC */
#define UDF_TAG_ID_INDIRECT_ENTRY                   UINT16_C(0x0103) /**< See UDFINDIRECTENTRY */
#define UDF_TAG_ID_TERMINAL_ENTRY                   UINT16_C(0x0104) /**< See UDFTERMINALENTRY */
#define UDF_TAG_ID_FILE_ENTRY                       UINT16_C(0x0105) /**< See UDFFILEENTRY */
#define UDF_TAG_ID_EXTENDED_ATTRIB_HDR_DESC         UINT16_C(0x0106) /**< See UDFEXTATTRIBHDRDESC */
#define UDF_TAG_ID_UNALLOCATED_SPACE_ENTRY          UINT16_C(0x0107) /**< See UDFUNALLOCATEDSPACEENTRY */
#define UDF_TAG_ID_SPACE_BITMAP_DESC                UINT16_C(0x0108) /**< See UDFSPACEBITMAPDESC */
#define UDF_TAG_ID_PARTITION_INTEGERITY_DESC        UINT16_C(0x0109) /**< See UDFPARTITIONINTEGRITYDESC */
#define UDF_TAG_ID_EXTENDED_FILE_ENTRY              UINT16_C(0x010a) /**< See UDFEXFILEENTRY */
/** @} */


/**
 * UDF primary volume descriptor (PVD) (@ecma167{3,10.1,50},
 * @udf260{2.2.2,27}).
 */
typedef struct UDFPRIMARYVOLUMEDESC
{
    /** 0x000: The descriptor tag (UDF_TAG_ID_PRIMARY_VOL_DESC). */
    UDFTAG          Tag;
    /** 0x010: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x014: Primary volume descriptor number. */
    uint32_t        uPrimaryVolumeDescNo;
    /** 0x018: Volume identifier (dstring). */
    UDFDSTRING      achVolumeID[32];
    /** 0x038: Volume sequence number. */
    uint16_t        uVolumeSeqNo;
    /** 0x03a: Maximum volume sequence number. */
    uint16_t        uMaxVolumeSeqNo;
    /** 0x03c: Interchange level. */
    uint16_t        uInterchangeLevel;
    /** 0x03e: Maximum interchange level. */
    uint16_t        uMaxInterchangeLevel;
    /** 0x040: Character set bitmask (aka list).  Each bit correspond to a
     * character set number. */
    uint32_t        fCharacterSets;
    /** 0x044: Maximum character set bitmask (aka list). */
    uint32_t        fMaxCharacterSets;
    /** 0x048: Volume set identifier (dstring).  This starts with 16 unique
     *  characters, the first 8 being the hex representation of a time value. */
    UDFDSTRING      achVolumeSetID[128];
    /** 0x0c8: Descriptor character set.
     * For achVolumeSetID and achVolumeID. */
    UDFCHARSPEC     DescCharSet;
    /** 0x108: Explanatory character set.
     * For VolumeAbstract and VolumeCopyrightNotice data. */
    UDFCHARSPEC     ExplanatoryCharSet;
    /** 0x148: Volume abstract. */
    UDFEXTENTAD     VolumeAbstract;
    /** 0x150: Volume copyright notice. */
    UDFEXTENTAD     VolumeCopyrightNotice;
    /** 0x158: Application identifier ("*Application ID"). */
    UDFENTITYID     idApplication;
    /** 0x178: Recording date and time. */
    UDFTIMESTAMP    RecordingTimestamp;
    /** 0x184: Implementation identifier ("*Developer ID"). */
    UDFENTITYID     idImplementation;
    /** 0x1a4: Implementation use. */
    uint8_t         abImplementationUse[64];
    /** 0x1e4: Predecessor volume descriptor sequence location. */
    uint32_t        offPredecessorVolDescSeq;
    /** 0x1e8: Flags (UDF_PVD_FLAGS_XXX). */
    uint16_t        fFlags;
    /** 0x1ea: Reserved. */
    uint8_t         abReserved[22];
} UDFPRIMARYVOLUMEDESC;
AssertCompileSize(UDFPRIMARYVOLUMEDESC, 512);
/** Pointer to a UDF primary volume descriptor. */
typedef UDFPRIMARYVOLUMEDESC *PUDFPRIMARYVOLUMEDESC;
/** Pointer to a const UDF primary volume descriptor. */
typedef UDFPRIMARYVOLUMEDESC const *PCUDFPRIMARYVOLUMEDESC;

/** @name UDF_PVD_FLAGS_XXX - Flags for UDFPRIMARYVOLUMEDESC::fFlags.
 * @{ */
/** Indicates that the volume set ID is common to all members of the set.  */
#define UDF_PVD_FLAGS_COMMON_VOLUME_SET_ID      UINT16_C(0x0001)
/** @} */


/**
 * UDF anchor volume descriptor pointer (AVDP) (@ecma167{3,10.2,53},
 * @udf260{2.2.3,29}).
 *
 * This is stored at least two of these locations:
 *      - logical sector 256
 *      - logical sector N - 256.
 *      - logical sector N.
 */
typedef struct UDFANCHORVOLUMEDESCPTR
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR). */
    UDFTAG          Tag;
    /** 0x10: The extent describing the main volume descriptor sequence. */
    UDFEXTENTAD     MainVolumeDescSeq;
    /** 0x18: Location of the backup descriptor sequence. */
    UDFEXTENTAD     ReserveVolumeDescSeq;
    /** 0x20: Reserved, probably must be zeros. */
    uint8_t         abReserved[0x1e0];
} UDFANCHORVOLUMEDESCPTR;
AssertCompileSize(UDFANCHORVOLUMEDESCPTR, 512);
/** Pointer to UDF anchor volume descriptor pointer. */
typedef UDFANCHORVOLUMEDESCPTR *PUDFANCHORVOLUMEDESCPTR;
/** Pointer to const UDF anchor volume descriptor pointer. */
typedef UDFANCHORVOLUMEDESCPTR const *PCUDFANCHORVOLUMEDESCPTR;


/**
 * UDF volume descriptor pointer (VDP) (@ecma167{3,10.3,53}).
 */
typedef struct UDFVOLUMEDESCPTR
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_VOLUME_DESC_PTR). */
    UDFTAG          Tag;
    /** 0x10: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x14: Location of the next volume descriptor sequence. */
    UDFEXTENTAD     NextVolumeDescSeq;
    /** 0x1c: Reserved, probably must be zeros. */
    uint8_t         abReserved[484];
} UDFVOLUMEDESCPTR;
AssertCompileSize(UDFVOLUMEDESCPTR, 512);
/** Pointer to UDF volume descriptor pointer. */
typedef UDFVOLUMEDESCPTR *PUDFVOLUMEDESCPTR;
/** Pointer to const UDF volume descriptor pointer. */
typedef UDFVOLUMEDESCPTR const *PCUDFVOLUMEDESCPTR;


/**
 * UDF implementation use volume descriptor (IUVD) (@ecma167{3,10.4,55},
 * @udf260{2.2.7,35}).
 */
typedef struct UDFIMPLEMENTATIONUSEVOLUMEDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_IMPLEMENTATION_USE_VOLUME_DESC). */
    UDFTAG          Tag;
    /** 0x10: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x14: The implementation identifier (UDF_ENTITY_ID_IUVD_IMPLEMENTATION). */
    UDFENTITYID     idImplementation;
    /** 0x34: The implementation use area. */
    union
    {
        /** Generic view. */
        uint8_t     ab[460];
        /** Logical volume information (@udf260{2.2.7.2,35}). */
        struct
        {
            /** 0x034: The character set used in this sub-structure. */
            UDFCHARSPEC     Charset;
            /** 0x074: Logical volume identifier. */
            UDFDSTRING      achVolumeID[128];
            /** 0x0f4: Info string \#1. */
            UDFDSTRING      achInfo1[36];
            /** 0x118: Info string \#2. */
            UDFDSTRING      achInfo2[36];
            /** 0x13c: Info string \#3. */
            UDFDSTRING      achInfo3[36];
            /** 0x160: The implementation identifier ("*Developer ID"). */
            UDFENTITYID     idImplementation;
            /** 0x180: Additional use bytes. */
            uint8_t         abUse[128];
        } Lvi;
    } ImplementationUse;
} UDFIMPLEMENTATIONUSEVOLUMEDESC;
AssertCompileSize(UDFIMPLEMENTATIONUSEVOLUMEDESC, 512);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.Charset,          0x034);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.achVolumeID,      0x074);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.achInfo1,         0x0f4);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.achInfo2,         0x118);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.achInfo3,         0x13c);
AssertCompileMemberOffset(UDFIMPLEMENTATIONUSEVOLUMEDESC, ImplementationUse.Lvi.idImplementation, 0x160);
/** Pointer to an UDF implementation use volume descriptor. */
typedef UDFIMPLEMENTATIONUSEVOLUMEDESC *PUDFIMPLEMENTATIONUSEVOLUMEDESC;
/** Pointer to a const UDF implementation use volume descriptor. */
typedef UDFIMPLEMENTATIONUSEVOLUMEDESC const *PCUDFIMPLEMENTATIONUSEVOLUMEDESC;


/**
 * UDF partition header descriptor (@ecma167{4,14.3,90}, @udf260{2.3.3,56}).
 *
 * This is found in UDFPARTITIONDESC::ContentsUse.
 */
typedef struct UDFPARTITIONHDRDESC
{
    /** 0x00: Unallocated space table location.  Zero length means no table. */
    UDFSHORTAD      UnallocatedSpaceTable;
    /** 0x08: Unallocated space bitmap location.  Zero length means no bitmap. */
    UDFSHORTAD      UnallocatedSpaceBitmap;
    /** 0x10: Partition integrity table location.  Zero length means no table. */
    UDFSHORTAD      PartitionIntegrityTable;
    /** 0x18: Freed space table location.  Zero length means no table. */
    UDFSHORTAD      FreedSpaceTable;
    /** 0x20: Freed space bitmap location.  Zero length means no bitmap. */
    UDFSHORTAD      FreedSpaceBitmap;
    /** 0x28: Reserved, MBZ. */
    uint8_t         abReserved[88];
} UDFPARTITIONHDRDESC;
AssertCompileSize(UDFPARTITIONHDRDESC, 128);
AssertCompileMemberOffset(UDFPARTITIONHDRDESC, PartitionIntegrityTable, 0x10);
AssertCompileMemberOffset(UDFPARTITIONHDRDESC, abReserved, 0x28);
/** Pointer to an UDF partition header descriptor. */
typedef UDFPARTITIONHDRDESC *PUDFPARTITIONHDRDESC;
/** Pointer to a const UDF partition header descriptor. */
typedef UDFPARTITIONHDRDESC const *PCUDFPARTITIONHDRDESC;


/**
 * UDF partition descriptor (PD) (@ecma167{3,10.5,55}, @udf260{2.2.14,51}).
 */
typedef struct UDFPARTITIONDESC
{
    /** 0x000: The descriptor tag (UDF_TAG_ID_PARTITION_DESC). */
    UDFTAG          Tag;
    /** 0x010: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x014: The partition flags (UDF_PARTITION_FLAGS_XXX).   */
    uint16_t        fFlags;
    /** 0x016: The partition number. */
    uint16_t        uPartitionNo;
    /** 0x018: Partition contents (UDF_ENTITY_ID_PD_PARTITION_CONTENTS_XXX). */
    UDFENTITYID     idPartitionContents;
    /** 0x038: partition contents use (depends on the idPartitionContents field). */
    union
    {
        /** Generic view. */
        uint8_t     ab[128];
        /** UDF partition header descriptor
         *  (UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF_3). */
        UDFPARTITIONHDRDESC Hdr;
    } ContentsUse;
    /** 0x0b8: Access type (UDF_PART_ACCESS_TYPE_XXX).  */
    uint32_t        uAccessType;
    /** 0x0bc: Partition starting location (logical sector number). */
    uint32_t        offLocation;
    /** 0x0c0: Partition length in sectors. */
    uint32_t        cSectors;
    /** 0x0c4: Implementation identifier ("*Developer ID"). */
    UDFENTITYID     idImplementation;
    /** 0x0e4: Implementation use bytes. */
    union
    {
        /** Generic view. */
        uint8_t     ab[128];
    } ImplementationUse;
    /** 0x164: Reserved. */
    uint8_t         abReserved[156];
} UDFPARTITIONDESC;
AssertCompileSize(UDFPARTITIONDESC, 512);
/** Pointer to an UDF partitions descriptor. */
typedef UDFPARTITIONDESC *PUDFPARTITIONDESC;
/** Pointer to a const UDF partitions descriptor. */
typedef const UDFPARTITIONDESC *PCUDFPARTITIONDESC;

/** @name UDF_PARTITION_FLAGS_XXX - UDF partition flags
 *
 * See @ecma167{3,10.5.3,56}.
 *
 * @{ */
/** Space has been allocated for this partition. */
#define UDF_PARTITION_FLAGS_ALLOCATED       UINT16_C(0x00000001)
/** @} */

/** @name UDF_PART_ACCESS_TYPE_XXX - UDF partition access types
 *
 * See @ecma167{3,10.5.7,57}, @udf260{2.2.14.2,51}.
 *
 * @{ */
/** Access not specified by this field. */
#define UDF_PART_ACCESS_TYPE_NOT_SPECIFIED  UINT32_C(0x00000000)
/** Read only: No writes. */
#define UDF_PART_ACCESS_TYPE_READ_ONLY      UINT32_C(0x00000001)
/** Write once: Sectors can only be written once. */
#define UDF_PART_ACCESS_TYPE_WRITE_ONCE     UINT32_C(0x00000002)
/** Rewritable: Logical sectors may require preprocessing before writing. */
#define UDF_PART_ACCESS_TYPE_REWRITABLE     UINT32_C(0x00000003)
/** Overwritable: No restrictions on writing. */
#define UDF_PART_ACCESS_TYPE_OVERWRITABLE   UINT32_C(0x00000004)
/** @} */


/**
 * Logical volume descriptor (LVD) (@ecma167{3,10.6,58}, @udf260{2.2.4,30}).
 *
 * @note Variable length.
 */
typedef struct UDFLOGICALVOLUMEDESC
{
    /** 0x000: The descriptor tag (UDF_TAG_ID_LOGICAL_VOLUME_DESC). */
    UDFTAG          Tag;
    /** 0x010: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x014: Character set used in the achLogicalVolumeID field.   */
    UDFCHARSPEC     DescCharSet;
    /** 0x054: The logical volume ID (label). */
    UDFDSTRING      achLogicalVolumeID[128];
    /** 0x0d4: Logical block size (in bytes). */
    uint32_t        cbLogicalBlock;
    /** 0x0d8: Domain identifier (UDF_ENTITY_ID_LVD_DOMAIN). */
    UDFENTITYID     idDomain;
    /** 0x0f8: Logical volume contents use. */
    union
    {
        /** Byte view. */
        uint8_t     ab[16];
        /** The extent containing the file set descriptor. */
        UDFLONGAD   FileSetDescriptor;
    } ContentsUse;
    /** 0x108: Map table length (in bytes). */
    uint32_t        cbMapTable;
    /** 0x10c: Number of partition maps. */
    uint32_t        cPartitionMaps;
    /** 0x110: Implementation identifier ("*Developer ID"). */
    UDFENTITYID     idImplementation;
    /** 0x130: Implementation use. */
    union
    {
        /** Byte view. */
        uint8_t     ab[128];
    } ImplementationUse;
    /** 0x1b0: Integrity sequence extent. Can be zero if cPartitionMaps is zero. */
    UDFEXTENTAD     IntegritySeqExtent;
    /** 0x1b8: Partition maps (length given by @a cbMapTable), data format is
     * defined by UDFPARTMAPHDR, UDFPARTMAPTYPE1 and UDFPARTMAPTYPE2. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abPartitionMaps[RT_FLEXIBLE_ARRAY];
} UDFLOGICALVOLUMEDESC;
AssertCompileMemberOffset(UDFLOGICALVOLUMEDESC, abPartitionMaps, 0x1b8);
/** Pointer to an UDF logical volume descriptor. */
typedef UDFLOGICALVOLUMEDESC *PUDFLOGICALVOLUMEDESC;
/** Pointer to a const UDF logical volume descriptor. */
typedef UDFLOGICALVOLUMEDESC const *PCUDFLOGICALVOLUMEDESC;

/**
 * Partition map header (UDFLOGICALVOLUMEDESC::abPartitionMaps).
 */
typedef struct UDFPARTMAPHDR
{
    /** 0x00: The partition map type. */
    uint8_t         bType;
    /** 0x01: The partition map length (header included). */
    uint8_t         cb;
} UDFPARTMAPHDR;
AssertCompileSize(UDFPARTMAPHDR, 2);
/** Pointer to a partition map header. */
typedef UDFPARTMAPHDR *PUDFPARTMAPHDR;
/** Pointer to a const partition map header. */
typedef UDFPARTMAPHDR const *PCUDFPARTMAPHDR;

/**
 * Partition map type 1 (UDFLOGICALVOLUMEDESC::abPartitionMaps).
 */
typedef struct UDFPARTMAPTYPE1
{
    /** 0x00: Header (uType=1, cb=6). */
    UDFPARTMAPHDR   Hdr;
    /** 0x02: Volume sequence number. */
    uint16_t        uVolumeSeqNo;
    /** 0x04: Partition number. */
    uint16_t        uPartitionNo;
} UDFPARTMAPTYPE1;
AssertCompileSize(UDFPARTMAPTYPE1, 6);
/** Pointer to a type 1 partition map. */
typedef UDFPARTMAPTYPE1 *PUDFPARTMAPTYPE1;
/** Pointer to a const type 1 partition map. */
typedef UDFPARTMAPTYPE1 const *PCUDFPARTMAPTYPE1;

/**
 * Partition map type 2 (UDFLOGICALVOLUMEDESC::abPartitionMaps).
 */
typedef struct UDFPARTMAPTYPE2
{
    /** 0x00: Header (uType=2, cb=64). */
    UDFPARTMAPHDR   Hdr;
    /** 0x02: Reserved \#1. */
    uint16_t        uReserved1;
    /** 0x04: Partition ID type (UDF_ENTITY_ID_VPM_PARTITION_TYPE,
     *  UDF_ENTITY_ID_SPM_PARTITION_TYPE, or UDF_ENTITY_ID_MPM_PARTITION_TYPE). */
    UDFENTITYID     idPartitionType;
    /** 0x24: Volume sequence number. */
    uint16_t        uVolumeSeqNo;
    /** 0x26: Partition number. */
    uint16_t        uPartitionNo;
    /** 0x28: Data specific to the partition ID type. */
    union
    {
        /** 0x28: Generic view. */
        uint8_t     ab[24];

        /** UDF_ENTITY_ID_VPM_PARTITION_TYPE. */
        struct
        {
            /** 0x28: Reserved. */
            uint8_t         abReserved2[24];
        } Vpm;

        /** UDF_ENTITY_ID_SPM_PARTITION_TYPE. */
        struct
        {
            /** 0x28: Packet length in blocks.   */
            uint16_t        cBlocksPerPacket;
            /** 0x2a: Number of sparing tables. */
            uint8_t         cSparingTables;
            /** 0x2b: Reserved padding byte. */
            uint8_t         bReserved2;
            /** 0x2c: The size of each sparing table. */
            uint32_t        cbSparingTable;
            /** 0x30: The sparing table locations (logical block). */
            uint32_t        aoffSparingTables[4];
        } Spm;

        /** UDF_ENTITY_ID_MPM_PARTITION_TYPE. */
        struct
        {
            /** 0x28: Metadata file entry location (logical block). */
            uint32_t        offMetadataFile;
            /** 0x2c: Metadata mirror file entry location (logical block). */
            uint32_t        offMetadataMirrorFile;
            /** 0x30: Metadata bitmap file entry location (logical block). */
            uint32_t        offMetadataBitmapFile;
            /** 0x34: The metadata allocation unit (logical blocks) */
            uint32_t        cBlocksAllocationUnit;
            /** 0x38: The metadata allocation unit alignment (logical blocks). */
            uint16_t        cBlocksAlignmentUnit;
            /** 0x3a: Flags, UDFPARTMAPMETADATA_F_XXX. */
            uint8_t         fFlags;
            /** 0x3b: Reserved. */
            uint8_t         abReserved2[5];
        } Mpm;
    } u;
} UDFPARTMAPTYPE2;
AssertCompileSize(UDFPARTMAPTYPE2, 64);
/** Pointer to a type 2 partition map. */
typedef UDFPARTMAPTYPE2 *PUDFPARTMAPTYPE2;
/** Pointer to a const type 2 partition map. */
typedef UDFPARTMAPTYPE2 const *PCUDFPARTMAPTYPE2;

/** @name UDFPARTMAPMETADATA_F_XXX
 * @{ */
/** Indicates that the metadata is mirrored too, not just the file entry. */
#define UDFPARTMAPMETADATA_F_DATA_MIRRORED      UINT8_C(1)
/** @} */


/**
 * UDF unallocated space descriptor (USD) (@ecma167{3,10.8,61}, @udf260{2.2.5,32}).
 *
 * @note Variable length.
 */
typedef struct UDFUNALLOCATEDSPACEDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_UNALLOCATED_SPACE_DESC). */
    UDFTAG          Tag;
    /** 0x10: Volume descriptor sequence number. */
    uint32_t        uVolumeDescSeqNo;
    /** 0x14: Number of allocation descriptors in the array below. */
    uint32_t        cAllocationDescriptors;
    /** 0x18: Allocation descriptors (variable length). */
    RT_FLEXIBLE_ARRAY_EXTENSION
    UDFEXTENTAD     aAllocationDescriptors[RT_FLEXIBLE_ARRAY];
} UDFUNALLOCATEDSPACEDESC;
AssertCompileMemberOffset(UDFUNALLOCATEDSPACEDESC, aAllocationDescriptors, 0x18);
/** Pointer to an UDF unallocated space descriptor. */
typedef UDFUNALLOCATEDSPACEDESC *PUDFUNALLOCATEDSPACEDESC;
/** Pointer to a const UDF unallocated space descriptor. */
typedef UDFUNALLOCATEDSPACEDESC const *PCUDFUNALLOCATEDSPACEDESC;


/**
 * UDF terminating descriptor (@ecma167{3,10.9,62}, @ecma167{4,14.2,62}).
 */
typedef struct UDFTERMINATINGDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_TERMINATING_DESC). */
    UDFTAG          Tag;
    /** 0x10: Reserved, MBZ. */
    uint8_t         abReserved[496];
} UDFTERMINATINGDESC;
/** Pointer to an UDF terminating descriptor. */
typedef UDFTERMINATINGDESC *PUDFTERMINATINGDESC;
/** Pointer to a const UDF terminating descriptor. */
typedef UDFTERMINATINGDESC const *PCUDFTERMINATINGDESC;


/**
 * UDF LVID implementation use structure (@udf260{2.2.6.4,33}).
 * This structure follows the two ECMA dictated tables in the LVID.
 */
typedef struct UDFLVIDIMPLUSEUDF
{
    /** 0x00: Implementation ID. */
    UDFENTITYID     idImplementation;
    /** 0x20: Number of files. */
    uint32_t        cFiles;
    /** 0x24: Number of directories. */
    uint32_t        cDirs;
    /** 0x28: Minimum UDF revision to read all the structures in the volume. */
    uint16_t        uMinUdfRevisionRead;
    /** 0x2a: Minimum UDF revision to successfully write to the volume. */
    uint16_t        uMinUdfRevisionWrite;
    /** 0x2c: Maximum UDF revision supported by the last writer. */
    uint16_t        uMaxUdfRevisionWrite;
    /** 0x2e: Implementation use. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abImplementationUse[RT_FLEXIBLE_ARRAY];
} UDFLVIDIMPLUSEUDF;
/** Pointer to an UDF LVID implemenation use structure. */
typedef UDFLVIDIMPLUSEUDF *PUDFLVIDIMPLUSEUDF;
/** Pointer to a const UDF LVID implemenation use structure. */
typedef UDFLVIDIMPLUSEUDF const *PCUDFLVIDIMPLUSEUDF;


/**
 * UDF logical volume integrity descriptor (LVID) (@ecma167{3,10.10,62},
 * @udf260{2.2.6,32}).
 */
typedef struct UDFLOGICALVOLINTEGRITYDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC). */
    UDFTAG          Tag;
    /** 0x10: Recording timestamp. */
    UDFTIMESTAMP    RecordingTimestamp;
    /** 0x1c: Integrity type (UDF_LVID_TYPE_XXX). */
    uint32_t        uIntegrityType;
    /** 0x20: The next integrity extent. */
    UDFEXTENTAD     NextIntegrityExtent;
    /** 0x28: Logical volume contents use. */
    union
    {
        struct
        {
            /** 0x28: Unique ID. */
            uint64_t    idUnique;
            /** 0x30: Reserved. */
            uint8_t     abReserved[24];
        } LVHdr;
        uint8_t         abContentUse[32];
    } ContentUse;
    /** 0x48: Number of partitions. */
    uint32_t        cPartitions;
    /** 0x4c: Length of implementation use. */
    uint32_t        cbImplementationUse;
    /**
     * 0x50: There are two tables each @a cPartitions in size.  The first is the
     * free space table.  The second the size table.
     *
     * Following these tables there are @a cbImplementationUse bytes of space for
     * the implementation to use.  With UDF this means UDFLVIDIMPLUSEUDF.
     */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint32_t        au32Tables[RT_FLEXIBLE_ARRAY];
} UDFLOGICALVOLINTEGRITYDESC;
AssertCompileMemberOffset(UDFLOGICALVOLINTEGRITYDESC, cbImplementationUse, 76);
AssertCompileMemberOffset(UDFLOGICALVOLINTEGRITYDESC, au32Tables, 80);
/** Pointer to an UDF logical volume integrity descriptor.   */
typedef UDFLOGICALVOLINTEGRITYDESC *PUDFLOGICALVOLINTEGRITYDESC;
/** Pointer to a const UDF logical volume integrity descriptor.   */
typedef UDFLOGICALVOLINTEGRITYDESC const *PCUDFLOGICALVOLINTEGRITYDESC;

/** @name UDF_LVID_TYPE_XXX - Integirty types.
 * @{ */
#define UDF_LVID_TYPE_OPEN          UINT32_C(0x00000000)
#define UDF_LVID_TYPE_CLOSE         UINT32_C(0x00000001)
/** @} */

/**
 * UDF file set descriptor (FSD) (@ecma167{4,14.1,86}, @udf260{2.3.2,54}).
 */
typedef struct UDFFILESETDESC
{
    /** 0x000: The descriptor tag (UDF_TAG_ID_FILE_SET_DESC). */
    UDFTAG          Tag;
    /** 0x010: Recording timestamp. */
    UDFTIMESTAMP    RecordingTimestamp;
    /** 0x01c: Interchange level. */
    uint16_t        uInterchangeLevel;
    /** 0x01e: Maximum interchange level. */
    uint16_t        uMaxInterchangeLevel;
    /** 0x020: Character set bitmask (aka list).  Each bit correspond to a
     * character set number. */
    uint32_t        fCharacterSets;
    /** 0x024: Maximum character set bitmask (aka list). */
    uint32_t        fMaxCharacterSets;
    /** 0x028: File set number. */
    uint32_t        uFileSetNo;
    /** 0x02c: File set descriptor number. */
    uint32_t        uFileSetDescNo;
    /** 0x030: Logical volume identifier character set. */
    UDFCHARSPEC     LogicalVolumeIDCharSet;
    /** 0x070: Logical volume identifier string. */
    UDFDSTRING      achLogicalVolumeID[128];
    /** 0x0e0: File set character set. */
    UDFCHARSPEC     FileSetCharSet;
    /** 0x130: Identifier string for this file set. */
    UDFDSTRING      achFileSetID[32];
    /** 0x150: Names a root file containing copyright info.  Optional. */
    UDFDSTRING      achCopyrightFile[32];
    /** 0x170: Names a root file containing an abstract for the file set.  Optional. */
    UDFDSTRING      achAbstractFile[32];
    /** 0x190: Root directory information control block location (ICB).
     * An ICB is a sequence made up of UDF_TAG_ID_FILE_ENTRY,
     * UDF_TAG_ID_INDIRECT_ENTRY, and UDF_TAG_ID_TERMINAL_ENTRY descriptors. */
    UDFLONGAD       RootDirIcb;
    /** 0x1a0: Domain identifier (UDF_ENTITY_FSD_LVD_DOMAIN).  Optional. */
    UDFENTITYID     idDomain;
    /** 0x1c0: Next location with file set descriptors location, 0 if none. */
    UDFLONGAD       NextExtent;
    /** 0x1d0: Location of the system stream directory associated with the
     * file set.  Optional. */
    UDFLONGAD       SystemStreamDirIcb;
    /** 0x1e0: Reserved, MBZ. */
    uint8_t         abReserved[32];
} UDFFILESETDESC;
AssertCompileSize(UDFFILESETDESC, 512);
/** Pointer to an UDF file set descriptor. */
typedef UDFFILESETDESC *PUDFFILESETDESC;
/** Pointer to a const UDF file set descriptor. */
typedef UDFFILESETDESC const *PCUDFFILESETDESC;


/**
 * UDF file identifier descriptor (FID) (@ecma167{4,14.4,91}, @udf260{2.3.4,57}).
 */
typedef struct UDFFILEIDDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_FILE_ID_DESC). */
    UDFTAG          Tag;
    /** 0x10: File version number (1..32767).  Always set to 1. */
    uint16_t        uVersion;
    /** 0x12: File characteristics (UDF_FILE_FLAGS_XXX). */
    uint8_t         fFlags;
    /** 0x13: File identifier (name) length. */
    uint8_t         cbName;
    /** 0x14: Location of an information control block describing the file.
     * Can be null if marked deleted.  The implementation defined part of
     * this contains additional flags and a unique ID. */
    UDFLONGAD       Icb;
    /** 0x24: Length of implementation use field (in bytes).  This can be zero.
     *
     * It can be used to prevent the following FID from spanning a block
     * boundrary, in which case it will be 32 bytes or more, and the it will
     * start with an UDFENTITYID identifying who last wrote it.
     *
     * The latter padding fun is a requirement from write-once media. */
    uint16_t        cbImplementationUse;
    /** 0x26: Two variable sized fields followed by padding to make the
     * actual structure size 4 byte aligned.  The first field in an
     * implementation use field with length given by @a cbImplementationUse.
     * After that is a d-string field with the name of the file, length
     * specified by @a cbName. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abImplementationUse[RT_FLEXIBLE_ARRAY];
} UDFFILEIDDESC;
AssertCompileMemberOffset(UDFFILEIDDESC, fFlags,              0x12);
AssertCompileMemberOffset(UDFFILEIDDESC, cbName,              0x13);
AssertCompileMemberOffset(UDFFILEIDDESC, Icb,                 0x14);
AssertCompileMemberOffset(UDFFILEIDDESC, abImplementationUse, 0x26);
/** Pointer to an UDF file set descriptor   */
typedef UDFFILEIDDESC *PUDFFILEIDDESC;
/** Pointer to a const UDF file set descriptor   */
typedef UDFFILEIDDESC const *PCUDFFILEIDDESC;

/** Get the pointer to the name field. */
#define UDFFILEIDDESC_2_NAME(a_pFid)        ((uint8_t const *)(&(a_pFid)->abImplementationUse[(a_pFid)->cbImplementationUse]))
/** Calculates the total size the size of a record.  */
#define UDFFILEIDDESC_CALC_SIZE_EX(cbImplementationUse, cbName) \
    RT_ALIGN_32((uint32_t)RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) + cbImplementationUse + cbName, 4)
/** Gets the actual size of a record. */
#define UDFFILEIDDESC_GET_SIZE(a_pFid)      UDFFILEIDDESC_CALC_SIZE_EX((a_pFid)->cbImplementationUse, (a_pFid)->cbName)

/** @name UDF_FILE_FLAGS_XXX
 * @{ */
/** Existence - Hide the file from the user. */
#define UDF_FILE_FLAGS_HIDDEN               UINT8_C(0x01)
/** Directory - Indicates a directory as apposed to some kind of file or symlink or something  (0). */
#define UDF_FILE_FLAGS_DIRECTORY            UINT8_C(0x02)
/** Deleted - Indicate that the file has been deleted.  Associated descriptors may still be valid, though. */
#define UDF_FILE_FLAGS_DELETED              UINT8_C(0x04)
/** Parent - Indicate the ICB field refers to the parent directory (or maybe
 * a file in case of streaming directory). */
#define UDF_FILE_FLAGS_PARENT               UINT8_C(0x08)
/** Metadata - Zero means user data, one means implementation specific metadata.
 *  Only allowed used in stream directory. */
#define UDF_FILE_FLAGS_METADATA             UINT8_C(0x10)
/** Reserved bits that should be zer.   */
#define UDF_FILE_FLAGS_RESERVED_MASK        UINT8_C(0xe0)
/** @} */


/**
 * UDF allocation extent descriptor (@ecma167{4,14.5,93}, @udf260{2.3.11,67}).
 */
typedef struct UDFALLOCATIONEXTENTDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_ALLOCATION_EXTENT_DESC). */
    UDFTAG          Tag;
    /** 0x10: Previous allocation extent location (logical block in current
     *  partition). */
    uint32_t        offPrevExtent;
    /** 0x14: Size of the following allocation descriptors (in bytes). */
    uint32_t        cbAllocDescs;
    /** 0x18: Allocation descriptors. */
    union
    {
        UDFSHORTAD  aShortADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        UDFLONGAD   aLongADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        UDFEXTAD    aExtADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
    } u;
} UDFALLOCATIONEXTENTDESC;
AssertCompileMemberOffset(UDFALLOCATIONEXTENTDESC, u, 0x18);
/** Pointer to an UDF allocation extent descriptor. */
typedef UDFALLOCATIONEXTENTDESC *PUDFALLOCATIONEXTENTDESC;
/** Pointer to a const UDF allocation extent descriptor. */
typedef UDFALLOCATIONEXTENTDESC const *PCUDFALLOCATIONEXTENTDESC;

/**
 * UDF information control block tag (@ecma167{4,14.6,93}, @udf260{2.3.5,60}).
 */
typedef struct UDFICBTAG
{
    /** 0x00: Number of direct entries in this ICB prior to this one. */
    uint32_t        cEntiresBeforeThis;
    /** 0x04: ICB hierarchy building strategy type (UDF_ICB_STRATEGY_TYPE_XXX). */
    uint16_t        uStrategyType;
    /** 0x06: Type specific parameters. */
    uint8_t         abStrategyParams[2];
    /** 0x08: Max number of direct and indirect entries that MAY be recorded in this ICB. */
    uint16_t        cMaxEntries;
    /** 0x0a: Reserved, MBZ. */
    uint8_t         bReserved;
    /** 0x0b: File type (UDF_FILE_TYPE_XXX). */
    uint8_t         bFileType;
    /** 0x0c: Parent ICB location. */
    UDFLBADDR       ParentIcb;
    /** 0x12: Parent ICB location (UDF_ICB_FLAGS_XXX). */
    uint16_t        fFlags;
} UDFICBTAG;
AssertCompileSize(UDFICBTAG, 20);
typedef UDFICBTAG *PUDFICBTAG;
typedef UDFICBTAG const *PCUDFICBTAG;

/** @name UDF_ICB_STRATEGY_TYPE_XXX - ICB hierarchy building strategies
 *
 * See @ecma167{4,14.6.2,94}, @udf260{6.6,121}
 *
 * @{ */
/** Strategy not specified. */
#define UDF_ICB_STRATEGY_TYPE_NOT_SPECIFIED     UINT16_C(0x0000)
/** See @ecma167{4,A.2,129}. */
#define UDF_ICB_STRATEGY_TYPE_1                 UINT16_C(0x0001)
/** See @ecma167{4,A.3,131}. */
#define UDF_ICB_STRATEGY_TYPE_2                 UINT16_C(0x0002)
/** See @ecma167{4,A.4,131}. */
#define UDF_ICB_STRATEGY_TYPE_3                 UINT16_C(0x0003)
/** See @ecma167{4,A.5,131}. */
#define UDF_ICB_STRATEGY_TYPE_4                 UINT16_C(0x0004)
/** Defined by the UDF spec, see @udf260{6.6,121}. */
#define UDF_ICB_STRATEGY_TYPE_4096              UINT16_C(0x1000)
/** @} */

/** @name UDF_ICB_FLAGS_XXX - ICB flags
 *
 * See @ecma167{4,14.6.8,95}, @udf260{2.3.5.4,61}
 *
 *  @{ */
/** Using UDFSHORTAD. */
#define UDF_ICB_FLAGS_AD_TYPE_SHORT             UINT16_C(0x0000)
/** Using UDFLONGAD. */
#define UDF_ICB_FLAGS_AD_TYPE_LONG              UINT16_C(0x0001)
/** Using UDFEXTAD. */
#define UDF_ICB_FLAGS_AD_TYPE_EXTENDED          UINT16_C(0x0002)
/** File content is embedded in the allocation descriptor area. */
#define UDF_ICB_FLAGS_AD_TYPE_EMBEDDED          UINT16_C(0x0003)
/** Allocation type mask. */
#define UDF_ICB_FLAGS_AD_TYPE_MASK              UINT16_C(0x0007)
/** Set on directories that are sorted (according to @ecma167{4,8.6.1,78}).
 * @note Directories are never sorted in UDF.  */
#define UDF_ICB_FLAGS_SORTED_DIRECTORY          UINT16_C(0x0008)
/** Not relocatable. */
#define UDF_ICB_FLAGS_NON_RELOCATABLE           UINT16_C(0x0010)
/** Indicate that the file needs backing up (DOS attribute). */
#define UDF_ICB_FLAGS_ARCHIVE                   UINT16_C(0x0020)
/** Set UID bit (UNIX). */
#define UDF_ICB_FLAGS_SET_UID                   UINT16_C(0x0040)
/** Set GID bit (UNIX). */
#define UDF_ICB_FLAGS_SET_GID                   UINT16_C(0x0080)
/** Set sticky bit (UNIX). */
#define UDF_ICB_FLAGS_STICKY                    UINT16_C(0x0100)
/** Extents are contiguous. */
#define UDF_ICB_FLAGS_CONTIGUOUS                UINT16_C(0x0200)
/** System bit, reserved for implementation use. */
#define UDF_ICB_FLAGS_SYSTEM                    UINT16_C(0x0400)
/** Data has been transformed in some way.
 * @note UDF shall not set this bit.  */
#define UDF_ICB_FLAGS_TRANSFORMED               UINT16_C(0x0800)
/** Directory may contain multi-versioned files.
 * @note UDF shall not set this bit.  */
#define UDF_ICB_FLAGS_MULTI_VERSIONS            UINT16_C(0x1000)
/** Is a stream in a stream directory. */
#define UDF_ICB_FLAGS_STREAM                    UINT16_C(0x2000)
/** Reserved mask. */
#define UDF_ICB_FLAGS_RESERVED_MASK             UINT16_C(0xc000)
/** @} */

/** @name UDF_FILE_TYPE_XXX - File types
 *
 * See @ecma167{4,14.6.6,94}, @udf260{2.3.5.2,60}
 *
 *  @{ */
#define UDF_FILE_TYPE_NOT_SPECIFIED             UINT8_C(0x00) /**< Not specified by this field. */
#define UDF_FILE_TYPE_UNALLOCATED_SPACE_ENTRY   UINT8_C(0x01)
#define UDF_FILE_TYPE_PARTITION_INTEGRITY_ENTRY UINT8_C(0x02)
#define UDF_FILE_TYPE_INDIRECT_ENTRY            UINT8_C(0x03)
#define UDF_FILE_TYPE_DIRECTORY                 UINT8_C(0x04)
#define UDF_FILE_TYPE_REGULAR_FILE              UINT8_C(0x05)
#define UDF_FILE_TYPE_BLOCK_DEVICE              UINT8_C(0x06)
#define UDF_FILE_TYPE_CHARACTER_DEVICE          UINT8_C(0x07)
#define UDF_FILE_TYPE_EXTENDED_ATTRIBUTES       UINT8_C(0x08)
#define UDF_FILE_TYPE_FIFO                      UINT8_C(0x09)
#define UDF_FILE_TYPE_SOCKET                    UINT8_C(0x0a)
#define UDF_FILE_TYPE_TERMINAL_ENTRY            UINT8_C(0x0b)
#define UDF_FILE_TYPE_SYMBOLIC_LINK             UINT8_C(0x0c)
#define UDF_FILE_TYPE_STREAM_DIRECTORY          UINT8_C(0x0d)
#define UDF_FILE_TYPE_VAT                       UINT8_C(0xf8)
#define UDF_FILE_TYPE_REAL_TIME_FILE            UINT8_C(0xf9)
#define UDF_FILE_TYPE_METADATA_FILE             UINT8_C(0xfa)
#define UDF_FILE_TYPE_METADATA_MIRROR_FILE      UINT8_C(0xfb)
#define UDF_FILE_TYPE_METADATA_BITMAP_FILE      UINT8_C(0xfc)
/** @} */


/**
 * UDF ICB header (derived structure).
 */
typedef struct UDFICBHDR
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_INDIRECT_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag. */
    UDFICBTAG       IcbTag;
} UDFICBHDR;
AssertCompileSize(UDFICBHDR, 36);
/** Pointer to an UDF ICB header. */
typedef UDFICBHDR *PUDFICBHDR;
/** Pointer to a const UDF ICB header. */
typedef UDFICBHDR const *PCUDFICBHDR;


/**
 * UDF indirect entry (@ecma167{4,14.7,96}).
 */
typedef struct UDFINDIRECTENTRY
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_INDIRECT_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag. */
    UDFICBTAG       IcbTag;
    /** 0x24: Indirect ICB location. */
    UDFLONGAD       IndirectIcb;
} UDFINDIRECTENTRY;
AssertCompileSize(UDFINDIRECTENTRY, 52);
/** Pointer to an UDF indirect entry. */
typedef UDFINDIRECTENTRY *PUDFINDIRECTENTRY;
/** Pointer to a const UDF indirect entry. */
typedef UDFINDIRECTENTRY const *PCUDFINDIRECTENTRY;


/**
 * UDF terminal entry (@ecma167{4,14.8,97}).
 */
typedef struct UDFTERMINALENTRY
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_TERMINAL_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag (UDF_FILE_TYPE_TERMINAL_ENTRY). */
    UDFICBTAG       IcbTag;
} UDFTERMINALENTRY;
AssertCompileSize(UDFTERMINALENTRY, 36);
/** Pointer to an UDF terminal entry. */
typedef UDFTERMINALENTRY *PUDFTERMINALENTRY;
/** Pointer to a const UDF terminal entry. */
typedef UDFTERMINALENTRY const *PCUDFTERMINALENTRY;


/**
 * UDF file entry (FE) (@ecma167{4,14.8,97}, @udf260{2.3.6,62}).
 *
 * @note Total length shall not exceed one logical block.
 */
typedef struct UDFFILEENTRY
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_FILE_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag. */
    UDFICBTAG       IcbTag;
    /** 0x24: User ID (UNIX). */
    uint32_t        uid;
    /** 0x28: Group ID (UNIX). */
    uint32_t        gid;
    /** 0x2c: Permission (UDF_PERM_XXX). */
    uint32_t        fPermissions;
    /** 0x30: Number hard links. */
    uint16_t        cHardlinks;
    /** 0x32: Record format (UDF_REC_FMT_XXX).   */
    uint8_t         uRecordFormat;
    /** 0x33: Record format (UDF_REC_ATTR_XXX).   */
    uint8_t         fRecordDisplayAttribs;
    /** 0x34: Record length (in bytes).
     * @note  Must be zero according to the UDF specification. */
    uint32_t        cbRecord;
    /** 0x38: Information length in bytes (file size). */
    uint64_t        cbData;
    /** 0x40: Number of logical blocks allocated (for file data). */
    uint64_t        cLogicalBlocks;
    /** 0x48: Time of last access (prior to recording the file entry). */
    UDFTIMESTAMP    AccessTime;
    /** 0x54: Time of last data modification. */
    UDFTIMESTAMP    ModificationTime;
    /** 0x60: Time of last attribute/status modification. */
    UDFTIMESTAMP    ChangeTime;
    /** 0x6c: Checkpoint number (defaults to 1). */
    uint32_t        uCheckpoint;
    /** 0x70: Extended attribute information control block location. */
    UDFLONGAD       ExtAttribIcb;
    /** 0x80: Implementation identifier ("*Developer ID"). */
    UDFENTITYID     idImplementation;
    /** 0xa0: Unique ID. */
    uint64_t        INodeId;
    /** 0xa8: Length of extended attributes in bytes, multiple of four. */
    uint32_t        cbExtAttribs;
    /** 0xac: Length of allocation descriptors in bytes, multiple of four. */
    uint32_t        cbAllocDescs;
    /** 0xb0: Two variable sized fields.  First @a cbExtAttribs bytes of extended
     *  attributes, then @a cbAllocDescs bytes of allocation descriptors. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abExtAttribs[RT_FLEXIBLE_ARRAY];
} UDFFILEENTRY;
AssertCompileMemberOffset(UDFFILEENTRY, abExtAttribs, 0xb0);
/** Pointer to an UDF file entry. */
typedef UDFFILEENTRY *PUDFFILEENTRY;
/** Pointer to a const UDF file entry. */
typedef UDFFILEENTRY const *PCUDFFILEENTRY;

/** @name UDF_PERM_XXX - UDFFILEENTRY::fPermissions
 * See @ecma167{4,14.9.5,99}.
 * @{ */
#define UDF_PERM_OTH_EXEC          UINT32_C(0x00000001)
#define UDF_PERM_OTH_WRITE         UINT32_C(0x00000002)
#define UDF_PERM_OTH_READ          UINT32_C(0x00000004)
#define UDF_PERM_OTH_ATTRIB        UINT32_C(0x00000008)
#define UDF_PERM_OTH_DELETE        UINT32_C(0x00000010)
#define UDF_PERM_OTH_MASK          UINT32_C(0x0000001f)

#define UDF_PERM_GRP_EXEC          UINT32_C(0x00000020)
#define UDF_PERM_GRP_WRITE         UINT32_C(0x00000040)
#define UDF_PERM_GRP_READ          UINT32_C(0x00000080)
#define UDF_PERM_GRP_ATTRIB        UINT32_C(0x00000100)
#define UDF_PERM_GRP_DELETE        UINT32_C(0x00000200)
#define UDF_PERM_GRP_MASK          UINT32_C(0x000003e0)

#define UDF_PERM_USR_EXEC          UINT32_C(0x00000400)
#define UDF_PERM_USR_WRITE         UINT32_C(0x00000800)
#define UDF_PERM_USR_READ          UINT32_C(0x00001000)
#define UDF_PERM_USR_ATTRIB        UINT32_C(0x00002000)
#define UDF_PERM_USR_DELETE        UINT32_C(0x00004000)
#define UDF_PERM_USR_MASK          UINT32_C(0x00007c00)

#define UDF_PERM_USR_RESERVED_MASK UINT32_C(0xffff8000)
/** @} */

/** @name UDF_REC_FMT_XXX - Record format.
 * See @ecma167{4,14.9.7,100}.
 * @{ */
/** Not record format specified.
 * @note The only allowed value according to the UDF specification. */
#define UDF_REC_FMT_NOT_SPECIFIED       UINT8_C(0x00)
/** @} */

/** @name UDF_REC_ATTR_XXX - Record display attributes.
 * See @ecma167{4,14.9.8,100}.
 * @{ */
/** Manner of record display not specified.
 * @note The only allowed value according to the UDF specification. */
#define UDF_REC_ATTR_NOT_SPECIFIED      UINT8_C(0x00)
/** @} */


/**
 * UDF extended attribute header descriptor (@ecma167{4,14.10.1,102},
 * @udf260{3.3.4,79}).
 */
typedef struct UDFEXTATTRIBHDRDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_EXTENDED_ATTRIB_HDR_DESC). */
    UDFTAG          Tag;
    /** 0x10: Implementation attributes location (byte offset) into the EA space.
     * This typically set to UINT32_MAX if not present, though any value larger
     * than the EA space will do. */
    uint32_t        offImplementationAttribs;
    /** 0x14: Application attributes location (byte offset) into the EA space.
     * This typically set to UINT32_MAX if not present, though any value larger
     * than the EA space will do. */
    uint32_t        offApplicationAttribs;
} UDFEXTATTRIBHDRDESC;
AssertCompileSize(UDFEXTATTRIBHDRDESC, 24);
/** Pointer to an UDF extended attribute header descriptor.  */
typedef UDFEXTATTRIBHDRDESC *PUDFEXTATTRIBHDRDESC;
/** Pointer to a const UDF extended attribute header descriptor.  */
typedef UDFEXTATTRIBHDRDESC const *PCUDFEXTATTRIBHDRDESC;

/**
 * UDF character set info EA data (@ecma167{4,14.10.3,104}).
 *
 * Not needed by UDF.
 */
typedef struct UDFEADATACHARSETINFO
{
    /** 0x00/0x0c: The length of the escape sequences (in bytes). */
    uint32_t        cbEscSeqs;
    /** 0x04/0x10: The character set type (UDF_CHAR_SET_TYPE_XXX). */
    uint8_t         bType;
    /** 0x05/0x11: Escape sequences. */
    uint8_t         abEscSeqs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
} UDFEADATACHARSETINFO;
/** Pointer to UDF character set info EA data. */
typedef UDFEADATACHARSETINFO *PUDFEADATACHARSETINFO;
/** Pointer to const UDF character set info EA data. */
typedef UDFEADATACHARSETINFO const *PCUDFEADATACHARSETINFO;
/** UDFGEA::uAttribType value for UDFEADATACHARSETINFO.*/
#define UDFEADATACHARSETINFO_ATTRIB_TYPE        UINT32_C(0x00000001)
/** UDFGEA::uAttribSubtype value for UDFEADATACHARSETINFO.   */
#define UDFEADATACHARSETINFO_ATTRIB_SUBTYPE     UINT32_C(0x00000001)

/**
 * UDF alternate permissions EA data (@ecma167{4,14.10.4,105}, @udf260{3.3.4.2,80}).
 * @note Not recorded according to the UDF specification.
 */
typedef struct UDFEADATAALTPERM
{
    /** 0x00/0x0c: Alternative owner ID. */
    uint16_t        idOwner;
    /** 0x02/0x0e: Alternative group ID. */
    uint16_t        idGroup;
    /** 0x04/0x10: Alternative permissions.   */
    uint16_t        fPermission;
} UDFEADATAALTPERM;
/** Pointer to UDF alternative permissions EA data. */
typedef UDFEADATAALTPERM *PUDFEADATAALTPERM;
/** Pointer to const UDF alternative permissions EA data. */
typedef UDFEADATAALTPERM const *PCUDFEADATAALTPERM;
/** UDFGEA::uAttribType value for UDFEADATAALTPERM.   */
#define UDFEADATAALTPERM_ATTRIB_TYPE            UINT32_C(0x00000003)
/** UDFGEA::uAttribSubtype value for UDFEADATAALTPERM.   */
#define UDFEADATAALTPERM_ATTRIB_SUBTYPE         UINT32_C(0x00000001)

/**
 * UDF file times EA data (@ecma167{4,14.10.5,108}, @udf260{3.3.4.3,80}).
 * (This is a bit reminiscent of ISO9660RRIPTF.)
 */
typedef struct UDFEADATAFILETIMES
{
    /** 0x00/0x0c: Timestamp length. */
    uint32_t        cbTimestamps;
    /** 0x04/0x10: Indicates which timestamps are present
     * (UDF_FILE_TIMES_EA_F_XXX). */
    uint32_t        fFlags;
    /** 0x08/0x14: Timestamps. */
    UDFTIMESTAMP    aTimestamps[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
} UDFEADATAFILETIMES;
/** Pointer to UDF file times EA data. */
typedef UDFEADATAFILETIMES *PUDFEADATAFILETIMES;
/** Pointer to const UDF file times EA data. */
typedef UDFEADATAFILETIMES const *PCUDFEADATAFILETIMES;
/** UDFGEA::uAttribType value for UDFEADATAFILETIMES.   */
#define UDFEADATAFILETIMES_ATTRIB_TYPE          UINT32_C(0x00000005)
/** UDFGEA::uAttribSubtype value for UDFEADATAFILETIMES.   */
#define UDFEADATAFILETIMES_ATTRIB_SUBTYPE       UINT32_C(0x00000001)

/** @name UDF_FILE_TIMES_EA_F_XXX - File times existence flags.
 * See @ecma167{4,14.10.5.6,109}
 * @{ */
#define UDF_FILE_TIMES_EA_F_BIRTH           UINT8_C(0x01) /**< Birth (creation) timestamp is recorded. */
#define UDF_FILE_TIMES_EA_F_DELETE          UINT8_C(0x04) /**< Deletion timestamp is recorded. */
#define UDF_FILE_TIMES_EA_F_EFFECTIVE       UINT8_C(0x08) /**< Effective timestamp is recorded. */
#define UDF_FILE_TIMES_EA_F_BACKUP          UINT8_C(0x20) /**< Backup timestamp is recorded. */
#define UDF_FILE_TIMES_EA_F_RESERVED_MASK   UINT8_C(0xd2)
/** @} */

/**
 * UDF information times EA data (@ecma167{4,14.10.6,109}).
 */
typedef struct UDFEADATAINFOTIMES
{
    /** 0x00/0x0c: Timestamp length. */
    uint32_t        cbTimestamps;
    /** 0x04/0x10: Indicates which timestamps are present
     * (UDF_INFO_TIMES_EA_F_XXX). */
    uint32_t        fFlags;
    /** 0x08/0x14: Timestamps. */
    UDFTIMESTAMP    aTimestamps[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
} UDFEADATAINFOTIMES;
/** Pointer to UDF information times EA data. */
typedef UDFEADATAINFOTIMES *PUDFEADATAINFOTIMES;
/** Pointer to const UDF information times EA data. */
typedef UDFEADATAINFOTIMES const *PCUDFEADATAINFOTIMES;
/** UDFGEA::uAttribType value for UDFEADATAINFOTIMES.   */
#define UDFEADATAINFOTIMES_ATTRIB_TYPE          UINT32_C(0x00000006)
/** UDFGEA::uAttribSubtype value for UDFEADATAINFOTIMES.   */
#define UDFEADATAINFOTIMES_ATTRIB_SUBTYPE       UINT32_C(0x00000001)

/** @name UDF_INFO_TIMES_EA_F_XXX - Information times existence flags.
 * See @ecma167{4,14.10.6.6,110}
 * @{ */
#define UDF_INFO_TIMES_EA_F_BIRTH           UINT8_C(0x01) /**< Birth (creation) timestamp is recorded. */
#define UDF_INFO_TIMES_EA_F_MODIFIED        UINT8_C(0x02) /**< Last (data) modified timestamp is recorded. */
#define UDF_INFO_TIMES_EA_F_EXPIRE          UINT8_C(0x04) /**< Expiration (deletion) timestamp is recorded. */
#define UDF_INFO_TIMES_EA_F_EFFECTIVE       UINT8_C(0x08) /**< Effective timestamp is recorded. */
#define UDF_INFO_TIMES_EA_F_RESERVED_MASK   UINT8_C(0xf0)
/** @} */

/**
 * UDF device specification EA data (@ecma167{4,14.10.7,110}, @udf260{3.3.4.4,81}).
 */
typedef struct UDFEADATADEVICESPEC
{
    /** 0x00/0x0c: Length of implementation use field. */
    uint32_t        cbImplementationUse;
    /** 0x04/0x10: Major device number. */
    uint32_t        uMajorDeviceNo;
    /** 0x08/0x14: Minor device number. */
    uint32_t        uMinorDeviceNo;
    /** 0x0c/0x18: Implementation use field (variable length).
     * UDF specficiation expects UDFENTITYID with a "*Developer ID" as first part
     * here. */
    uint8_t         abImplementationUse[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
} UDFEADATADEVICESPEC;
/** Pointer to UDF device specification EA data. */
typedef UDFEADATADEVICESPEC *PUDFEADATADEVICESPEC;
/** Pointer to const UDF device specification EA data. */
typedef UDFEADATADEVICESPEC const *PCUDFEADATADEVICESPEC;
/** UDFGEA::uAttribType value for UDFEADATADEVICESPEC.   */
#define UDFEADATADEVICESPEC_ATTRIB_TYPE         UINT32_C(0x0000000c)
/** UDFGEA::uAttribSubtype value for UDFEADATADEVICESPEC.   */
#define UDFEADATADEVICESPEC_ATTRIB_SUBTYPE      UINT32_C(0x00000001)

/**
 * UDF free EA space payload for implementation and application use EAs
 * (@udf260{3.3.4.5.1.1,82}, @udf260{3.3.4.6.1.1,88}).
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_FREE_EA_SPACE.
 * UDFEADATAAPPUSE::idImplementation is UDF_ENTITY_ID_AUEA_FREE_EA_SPACE.
 */
typedef struct UDFFREEEASPACE
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: Free space. */
    uint8_t         abFree[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
} UDFFREEEASPACE;
/** Pointer to UDF free EA space impl/app use payload. */
typedef UDFFREEEASPACE *PUDFFREEEASPACE;
/** Pointer to const UDF free EA space impl/app use payload. */
typedef UDFFREEEASPACE const *PCUDFFREEEASPACE;

/**
 * UDF DVD copyright management information implementation use EA payload
 * (@udf260{3.3.4.5.1.2,83}).
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_DVD_CGMS_INFO.
 */
typedef struct UDFIUEADVDCGMSINFO
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: The CGMS information (whatever that is). */
    uint8_t         bInfo;
    /** 0x03/0x33: Data structure type (whatever that is). */
    uint8_t         bType;
    /** 0x04/0x34: Production system information, probably dependend on the
     * values of previous fields. */
    uint8_t         abProtSysInfo[4];
} UDFIUEADVDCGMSINFO;
/** Pointer to UDF DVD copyright management information implementation use EA payload. */
typedef UDFIUEADVDCGMSINFO *PUDFIUEADVDCGMSINFO;
/** Pointer to const UDF DVD copyright management information implementation use EA payload. */
typedef UDFIUEADVDCGMSINFO const *PCUDFIUEADVDCGMSINFO;

/**
 * UDF OS/2 EA length implementation use EA payload (@udf260{3.3.4.5.3.1,84}).
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_OS2_EA_LENGTH.
 */
#pragma pack(2)
typedef struct UDFIUEAOS2EALENGTH
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: The CGMS information (whatever that is). */
    uint32_t        cbEAs;
} UDFIUEAOS2EALENGTH;
#pragma pack()
AssertCompileMemberOffset(UDFIUEAOS2EALENGTH, cbEAs, 2);
/** Pointer to UDF OS/2 EA length implementation use EA payload. */
typedef UDFIUEAOS2EALENGTH *PUDFIUEAOS2EALENGTH;
/** Pointer to const UDF OS/2 EA length implementation use EA payload. */
typedef UDFIUEAOS2EALENGTH const *PCUDFIUEAOS2EALENGTH;

/**
 * UDF Mac volume info implementation use EA payload (@udf260{3.3.4.5.4.1,84}).
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_MAC_VOLUME_INFO.
 */
#pragma pack(2)
typedef struct UDFIUEAMACVOLINFO
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: Last modification time. */
    UDFTIMESTAMP    LastModificationTime;
    /** 0x0e/0x3e: Last backup time. */
    UDFTIMESTAMP    LastBackupTime;
    /** 0x1a/0x4e: Volume finder information. */
    uint32_t        au32FinderInfo[8];
} UDFIUEAMACVOLINFO;
#pragma pack()
AssertCompileMemberOffset(UDFIUEAMACVOLINFO, au32FinderInfo, 0x1a);
/** Pointer to UDF Mac volume info implementation use EA payload. */
typedef UDFIUEAMACVOLINFO *PUDFIUEAMACVOLINFO;
/** Pointer to const UDF Mac volume info implementation use EA payload. */
typedef UDFIUEAMACVOLINFO const *PCUDFIUEAMACVOLINFO;

/**
 * UDF point for use in Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACPOINT
{
    /** X coordinate. */
    int16_t         x;
    /** Y coordinate. */
    int16_t         y;
} UDFMACPOINT;

/**
 * UDF rectangle for using Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACRECT
{
    /** top Y coordinate. */
    int16_t         yTop;
    /** left X coordinate. */
    int16_t         xLeft;
    /** bottom Y coordinate. (exclusive?) */
    int16_t         yBottom;
    /** right X coordinate. (exclusive?) */
    int16_t         xRight;
} UDFMACRECT;

/**
 * UDF finder directory info for Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACFDINFO
{
    UDFMACRECT      FrRect;
    int16_t         FrFlags;
    UDFMACPOINT     FrLocation;
    int16_t         FrView;
} UDFMACFDINFO;
AssertCompileSize(UDFMACFDINFO, 16);

/**
 * UDF finder directory extended info for Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACFDXINFO
{
    UDFMACPOINT     FrScroll;
    int32_t         FrOpenChain;
    uint8_t         FrScript;
    uint8_t         FrXFlags;
    uint16_t        FrComment;
    uint32_t        FrPutAway;
} UDFMACFDXINFO;
AssertCompileSize(UDFMACFDXINFO, 16);

/**
 * UDF Mac finder info implementation use EA payload (@udf260{3.3.4.5.4.1,84}),
 * directory edition.
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_MAC_FINDER_INFO.
 */
typedef struct UDFIUEAMACFINDERINFODIR
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: Explicit alignment padding, MBZ. */
    uint16_t        uPadding;
    /** 0x04/0x34: Parent directory ID. */
    uint32_t        idParentDir;
    /** 0x08/0x38: Dir information. */
    UDFMACFDINFO    DirInfo;
    /** 0x18/0x48: Dir extended information. */
    UDFMACFDXINFO   DirExInfo;
} UDFIUEAMACFINDERINFODIR;
AssertCompileMemberOffset(UDFIUEAMACFINDERINFODIR, DirInfo, 0x08);
AssertCompileMemberOffset(UDFIUEAMACFINDERINFODIR, DirExInfo, 0x18);
AssertCompileSize(UDFIUEAMACFINDERINFODIR, 0x28);
/** Pointer to UDF Mac finder info for dir implementation use EA payload. */
typedef UDFIUEAMACFINDERINFODIR *PUDFIUEAMACFINDERINFODIR;
/** Pointer to const UDF Mac finder info for dir implementation use EA payload. */
typedef UDFIUEAMACFINDERINFODIR const *PCUDFIUEAMACFINDERINFODIR;

/**
 * UDF finder file info for Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACFFINFO
{
    uint32_t        FrType;
    uint32_t        FrCreator;
    uint16_t        FrFlags;
    UDFMACPOINT     FrLocation;
    int16_t         FrFldr;
} UDFMACFFINFO;
AssertCompileSize(UDFMACFFINFO, 16);

/**
 * UDF finder file extended info for Mac EAs (@udf260{3.3.4.5.4.2,86}).
 */
typedef struct UDFMACFFXINFO
{
    int16_t         FrIconID;
    uint8_t         FdUnused[6];
    uint8_t         FrScript;
    uint8_t         FrXFlags;
    uint16_t        FrComment;
    uint32_t        FrPutAway;
} UDFMACFFXINFO;
AssertCompileSize(UDFMACFFXINFO, 16);

/**
 * UDF Mac finder info implementation use EA payload (@udf260{3.3.4.5.4.1,84}),
 * file edition.
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_MAC_FINDER_INFO.
 */
typedef struct UDFIUEAMACFINDERINFOFILE
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: Explicit alignment padding, MBZ. */
    uint16_t        uPadding;
    /** 0x04/0x34: Parent directory ID. */
    uint32_t        idParentDir;
    /** 0x08/0x38: File information. */
    UDFMACFFINFO    FileInfo;
    /** 0x18/0x48: File extended information. */
    UDFMACFFXINFO   FileExInfo;
    /** 0x28/0x58: The size of the fork data (in bytes). */
    uint32_t        cbForkData;
    /** 0x2c/0x5c: The size of the fork allocation (in bytes). */
    uint32_t        cbForkAlloc;
} UDFIUEAMACFINDERINFOFILE;
AssertCompileMemberOffset(UDFIUEAMACFINDERINFOFILE, FileInfo, 0x08);
AssertCompileMemberOffset(UDFIUEAMACFINDERINFOFILE, FileExInfo, 0x18);
AssertCompileMemberOffset(UDFIUEAMACFINDERINFOFILE, cbForkData, 0x28);
AssertCompileSize(UDFIUEAMACFINDERINFOFILE, 0x30);
/** Pointer to UDF Mac finder info for file implementation use EA payload. */
typedef UDFIUEAMACFINDERINFOFILE *PUDFIUEAMACFINDERINFOFILE;
/** Pointer to const UDF Mac finder info for file implementation use EA payload. */
typedef UDFIUEAMACFINDERINFOFILE const *PCUDFIUEAMACFINDERINFOFILE;

/**
 * UDF OS/400 directory info implementation use EA payload (@udf260{3.3.4.5.6.1,87})
 *
 * UDFEADATAIMPLUSE::idImplementation is UDF_ENTITY_ID_IUEA_OS400_DIR_INFO.
 */
typedef struct UDFIUEAOS400DIRINFO
{
    /** 0x00/0x30: Header checksum.
     * @note 16-bit checksum of UDFGEA up thru u.ImplUse.idImplementation. */
    uint16_t        uChecksum;
    /** 0x02/0x32: Explicit alignment padding, MBZ. */
    uint16_t        uPadding;
    /** 0x04/0x34: The directory info, format documented elsewhere. */
    uint8_t         abDirInfo[44];
} UDFIUEAOS400DIRINFO;
AssertCompileSize(UDFIUEAOS400DIRINFO, 0x30);
/** Pointer to UDF Mac finder info for file implementation use EA payload. */
typedef UDFIUEAOS400DIRINFO *PUDFIUEAOS400DIRINFO;
/** Pointer to const UDF Mac finder info for file implementation use EA payload. */
typedef UDFIUEAOS400DIRINFO const *PCUDFIUEAOS400DIRINFO;


/**
 * UDF implementation use EA data (@ecma167{4,14.10.8,111}, @udf260{3.3.4.5,82}).
 */
typedef struct UDFEADATAIMPLUSE
{
    /** 0x00/0x0c: Length uData in bytes. */
    uint32_t        cbData;
    /** 0x04/0x10: Implementation identifier (UDF_ENTITY_ID_IUEA_XXX). */
    UDFENTITYID     idImplementation;
    /** 0x24/0x30: Implementation use field (variable length). */
    union
    {
        /** Generic byte view. */
        uint8_t                     abData[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        /** Free EA space (UDF_ENTITY_ID_IUEA_FREE_EA_SPACE). */
        UDFFREEEASPACE              FreeEaSpace;
        /** DVD copyright management information (UDF_ENTITY_ID_IUEA_DVD_CGMS_INFO). */
        UDFIUEADVDCGMSINFO          DvdCgmsInfo;
        /** OS/2 EA length (UDF_ENTITY_ID_IUEA_OS2_EA_LENGTH). */
        UDFIUEAOS2EALENGTH          Os2EaLength;
        /** Mac volume info (UDF_ENTITY_ID_IUEA_MAC_VOLUME_INFO). */
        UDFIUEAMACVOLINFO           MacVolInfo;
        /** Mac finder info, directory edition (UDF_ENTITY_ID_IUEA_MAC_FINDER_INFO). */
        UDFIUEAMACFINDERINFODIR     MacFinderInfoDir;
        /** Mac finder info, file edition (UDF_ENTITY_ID_IUEA_MAC_FINDER_INFO). */
        UDFIUEAMACFINDERINFOFILE    MacFinderInfoFile;
        /** OS/400 directory info (UDF_ENTITY_ID_IUEA_OS400_DIR_INFO). */
        UDFIUEAOS400DIRINFO         Os400DirInfo;
    } u;
} UDFEADATAIMPLUSE;
/** Pointer to UDF implementation use EA data. */
typedef UDFEADATAIMPLUSE *PUDFEADATAIMPLUSE;
/** Pointer to const UDF implementation use EA data. */
typedef UDFEADATAIMPLUSE const *PCUDFEADATAIMPLUSE;
/** UDFGEA::uAttribType value for UDFEADATAIMPLUSE.   */
#define UDFEADATAIMPLUSE_ATTRIB_TYPE            UINT32_C(0x00000800)
/** UDFGEA::uAttribSubtype value for UDFEADATAIMPLUSE.   */
#define UDFEADATAIMPLUSE_ATTRIB_SUBTYPE         UINT32_C(0x00000001)

/**
 * UDF application use EA data (@ecma167{4,14.10.9,112}, @udf260{3.3.4.6,88}).
 */
typedef struct UDFEADATAAPPUSE
{
    /** 0x0c: Length uData in bytes. */
    uint32_t        cbData;
    /** 0x10: Application identifier (UDF_ENTITY_ID_AUEA_FREE_EA_SPACE). */
    UDFENTITYID     idApplication;
    /** 0x30: Application use field (variable length). */
    union
    {
        /** Generic byte view. */
        uint8_t             ab[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        /** Free EA space (UDF_ENTITY_ID_AUEA_FREE_EA_SPACE). */
        UDFFREEEASPACE      FreeEaSpace;
    } uData;
} UDFEADATAAPPUSE;
/** Pointer to UDF application use EA data. */
typedef UDFEADATAAPPUSE *PUDFEADATAAPPUSE;
/** Pointer to const UDF application use EA data. */
typedef UDFEADATAAPPUSE const *PCUDFEADATAAPPUSE;
/** UDFGEA::uAttribType value for UDFEADATAAPPUSE.   */
#define UDFEADATAAPPUSE_ATTRIB_TYPE             UINT32_C(0x00010000)
/** UDFGEA::uAttribSubtype value for UDFEADATAAPPUSE.   */
#define UDFEADATAAPPUSE_ATTRIB_SUBTYPE          UINT32_C(0x00000001)

/**
 * UDF generic extended attribute (@ecma167{4,14.10.2,103}).
 */
typedef struct UDFGEA
{
    /** 0x00: Attribute type (UDFXXX_ATTRIB_TYPE). */
    uint32_t        uAttribType;
    /** 0x04: Attribute subtype (UDFXXX_ATTRIB_SUBTYPE). */
    uint8_t         uAttribSubtype;
    /** 0x05: Reserved padding bytes, MBZ. */
    uint8_t         abReserved[3];
    /** 0x08: Size of the whole extended attribute.
     * Multiple of four is recommended. */
    uint32_t        cbAttrib;
    /** 0x0c: Attribute data union. */
    union
    {
        /** Generic byte view (variable size). */
        uint8_t                 abData[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        /** Character set information (@ecma167{4,14.10.3,104}). */
        UDFEADATACHARSETINFO    CharSetInfo;
        /** Alternate permissions (@ecma167{4,14.10.4,105}, @udf260{3.3.4.2,80}).
         * @note Not recorded according to the UDF specification.  */
        UDFEADATAALTPERM        AltPerm;
        /** File times (@ecma167{4,14.10.5,108}, @udf260{3.3.4.3,80}).
         * (This is a bit reminiscent of ISO9660RRIPTF.) */
        UDFEADATAFILETIMES      FileTimes;
        /** Information times (@ecma167{4,14.10.6,109}). */
        UDFEADATAINFOTIMES      InfoTimes;
        /** Device specification (@ecma167{4,14.10.7,110}, @udf260{3.3.4.4,81}). */
        UDFEADATADEVICESPEC     DeviceSpec;
        /** Implementation use (@ecma167{4,14.10.8,111}, @udf260{3.3.4.5,82}). */
        UDFEADATAIMPLUSE        ImplUse;
        /** Application use (@ecma167{4,14.10.9,112}, @udf260{3.3.4.6,88}). */
        UDFEADATAAPPUSE         AppUse;
    } u;
} UDFGEA;
AssertCompileMemberOffset(UDFGEA, u, 0x0c);
/** Pointer to a UDF extended attribute. */
typedef UDFGEA *PUDFGEA;
/** Pointer to a const UDF extended attribute. */
typedef UDFGEA const *PCUDFGEA;


/**
 * UDF unallocated space entry (@ecma167{4,14.11,113}, @udf260{2.3.7,64}).
 *
 * @note Total length shall not exceed one logical block.
 */
typedef struct UDFUNALLOCATEDSPACEENTRY
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_UNALLOCATED_SPACE_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag. */
    UDFICBTAG       IcbTag;
    /** 0x24: Size of the allocation desciptors in bytes. */
    uint32_t        cbAllocDescs;
    /** 0x28: Allocation desciptors, type given by IcbTag::fFlags. */
    union
    {
        UDFSHORTAD  aShortADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        UDFLONGAD   aLongADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        UDFEXTAD    aExtADs[RT_FLEXIBLE_ARRAY_IN_NESTED_UNION];
        UDFEXTENTAD SingleAD;
    } u;
} UDFUNALLOCATEDSPACEENTRY;
AssertCompileMemberOffset(UDFUNALLOCATEDSPACEENTRY, u, 0x28);
/** Pointer to an UDF unallocated space entry. */
typedef UDFUNALLOCATEDSPACEENTRY *PUDFUNALLOCATEDSPACEENTRY;
/** Pointer to a const UDF unallocated space entry. */
typedef UDFUNALLOCATEDSPACEENTRY const *PCUDFUNALLOCATEDSPACEENTRY;


/**
 * UDF space bitmap descriptor (SBD) (@ecma167{4,14.12,114}, @udf260{2.3.8,65}).
 */
typedef struct UDFSPACEBITMAPDESC
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_SPACE_BITMAP_DESC). */
    UDFTAG          Tag;
    /** 0x10: Number of bits in the bitmap. */
    uint32_t        cBits;
    /** 0x14: The bitmap size in bytes. */
    uint32_t        cbBitmap;
    /** 0x18: The bitmap. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abBitmap[RT_FLEXIBLE_ARRAY];
} UDFSPACEBITMAPDESC;
AssertCompileMemberOffset(UDFSPACEBITMAPDESC, abBitmap, 0x18);
/** Pointer to an UDF space bitmap descriptor. */
typedef UDFSPACEBITMAPDESC *PUDFSPACEBITMAPDESC;
/** Pointer to a const UDF space bitmap descriptor. */
typedef UDFSPACEBITMAPDESC const *PCUDFSPACEBITMAPDESC;


/**
 * UDF partition integrity descriptor (@ecma167{4,14.3,115}, @udf260{2.3.9,65}).
 *
 * @note Not needed by UDF.
 */
typedef struct UDFPARTITIONINTEGRITYDESC
{
    /** 0x000: The descriptor tag (UDF_TAG_ID_PARTITION_INTEGERITY_DESC). */
    UDFTAG          Tag;
    /** 0x010: ICB Tag. */
    UDFICBTAG       IcbTag;
    /** 0x024: Recording timestamp. */
    UDFTIMESTAMP    RecordingTimestamp;
    /** 0x030: Interity type (UDF_PARTITION_INTEGRITY_TYPE_XXX). */
    uint8_t         bType;
    /** 0x031: Reserved. */
    uint8_t         abReserved[175];
    /** 0x0e0: Implementation identifier. */
    UDFENTITYID     idImplementation;
    /** 0x100: Implementation use data. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abImplementationUse[RT_FLEXIBLE_ARRAY];
} UDFPARTITIONINTEGRITYDESC;
AssertCompileMemberOffset(UDFPARTITIONINTEGRITYDESC, abImplementationUse, 0x100);
/** Pointer to an UDF partition integrity descriptor. */
typedef UDFPARTITIONINTEGRITYDESC *PUDFPARTITIONINTEGRITYDESC;
/** Pointer to a const UDF partition integrity descriptor. */
typedef UDFPARTITIONINTEGRITYDESC const *PCUDFPARTITIONINTEGRITYDESC;


/**
 * UDF extended file entry (EFE) (@ecma167{4,14.17,120}, @udf260{3.3.5,83}).
 *
 * @note Total length shall not exceed one logical block.
 */
typedef struct UDFEXFILEENTRY
{
    /** 0x00: The descriptor tag (UDF_TAG_ID_EXTENDED_FILE_ENTRY). */
    UDFTAG          Tag;
    /** 0x10: ICB Tag. */
    UDFICBTAG       IcbTag;
    /** 0x24: User ID (UNIX). */
    uint32_t        uid;
    /** 0x28: Group ID (UNIX). */
    uint32_t        gid;
    /** 0x2c: Permission (UDF_PERM_XXX). */
    uint32_t        fPermissions;
    /** 0x30: Number hard links. */
    uint16_t        cHardlinks;
    /** 0x32: Record format (UDF_REC_FMT_XXX).   */
    uint8_t         uRecordFormat;
    /** 0x33: Record format (UDF_REC_FMT_XXX).   */
    uint8_t         fRecordDisplayAttribs;
    /** 0x34: Record length (in bytes).
     * @note  Must be zero according to the UDF specification. */
    uint32_t        cbRecord;
    /** 0x38: Information length in bytes (file size). */
    uint64_t        cbData;
    /** 0x40: The size of all streams. Same as cbData if no additional streams. */
    uint64_t        cbObject;
    /** 0x48: Number of logical blocks allocated (for file data). */
    uint64_t        cLogicalBlocks;
    /** 0x50: Time of last access (prior to recording the file entry). */
    UDFTIMESTAMP    AccessTime;
    /** 0x5c: Time of last data modification. */
    UDFTIMESTAMP    ModificationTime;
    /** 0x68: Birth (creation) time. */
    UDFTIMESTAMP    BirthTime;
    /** 0x74: Time of last attribute/status modification. */
    UDFTIMESTAMP    ChangeTime;
    /** 0x80: Checkpoint number (defaults to 1). */
    uint32_t        uCheckpoint;
    /** 0x84: Reserved, MBZ. */
    uint32_t        uReserved;
    /** 0x88: Extended attribute information control block location. */
    UDFLONGAD       ExtAttribIcb;
    /** 0x98: Stream directory information control block location. */
    UDFLONGAD       StreamDirIcb;
    /** 0xa8: Implementation identifier (UDF_ENTITY_ID_FE_IMPLEMENTATION). */
    UDFENTITYID     idImplementation;
    /** 0xc8: Unique ID. */
    uint64_t        INodeId;
    /** 0xd0: Length of extended attributes in bytes, multiple of four. */
    uint32_t        cbExtAttribs;
    /** 0xd4: Length of allocation descriptors in bytes, multiple of four. */
    uint32_t        cbAllocDescs;
    /** 0xd8: Two variable sized fields.  First @a cbExtAttribs bytes of extended
     *  attributes, then @a cbAllocDescs bytes of allocation descriptors. */
    RT_FLEXIBLE_ARRAY_EXTENSION
    uint8_t         abExtAttribs[RT_FLEXIBLE_ARRAY];
} UDFEXFILEENTRY;
AssertCompileMemberOffset(UDFEXFILEENTRY, abExtAttribs, 0xd8);
/** Pointer to an UDF extended file entry. */
typedef UDFEXFILEENTRY *PUDFEXFILEENTRY;
/** Pointer to a const UDF extended file entry. */
typedef UDFEXFILEENTRY const *PCUDFEXFILEENTRY;



/** @name UDF Volume Recognition Sequence (VRS)
 *
 * The recognition sequence usually follows the CD001 descriptor sequence at
 * sector 16 and is there to indicate that the medium (also) contains a UDF file
 * system and which standards are involved.
 *
 * See @ecma167{2,8,31}, @ecma167{2,9,32}, @udf260{2.1.7,25}.
 *
 * @{ */

/** The type value used for all the extended UDF volume descriptors
 * (ISO9660VOLDESCHDR::bDescType). */
#define UDF_EXT_VOL_DESC_TYPE               0
/** The version value used for all the extended UDF volume descriptors
 *  (ISO9660VOLDESCHDR::bDescVersion). */
#define UDF_EXT_VOL_DESC_VERSION            1

/** Standard ID for UDFEXTVOLDESCBEGIN. */
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN   "BEA01"
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN_0 'B'
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN_1 'E'
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN_2 'A'
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN_3 '0'
#define UDF_EXT_VOL_DESC_STD_ID_BEGIN_4 '1'
/** Standard ID for UDFEXTVOLDESCTERM. */
#define UDF_EXT_VOL_DESC_STD_ID_TERM    "TEA01"
#define UDF_EXT_VOL_DESC_STD_ID_TERM_0  'T'
#define UDF_EXT_VOL_DESC_STD_ID_TERM_1  'E'
#define UDF_EXT_VOL_DESC_STD_ID_TERM_2  'A'
#define UDF_EXT_VOL_DESC_STD_ID_TERM_3  '0'
#define UDF_EXT_VOL_DESC_STD_ID_TERM_4  '1'
/** Standard ID for UDFEXTVOLDESCNSR following ECMA-167 2nd edition. */
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02  "NSR02"
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02_0 'N'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02_1 'S'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02_2 'R'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02_3 '0'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_02_4 '2'
/** Standard ID for UDFEXTVOLDESCNSR following ECMA-167 3rd edition. */
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03  "NSR03"
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03_0 'N'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03_1 'S'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03_2 'R'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03_3 '0'
#define UDF_EXT_VOL_DESC_STD_ID_NSR_03_4 '3'
/** Standard ID for UDFEXTVOLDESCBOOT. */
#define UDF_EXT_VOL_DESC_STD_ID_BOOT    "BOOT2"
#define UDF_EXT_VOL_DESC_STD_ID_BOOT_0  'B'
#define UDF_EXT_VOL_DESC_STD_ID_BOOT_1  'O'
#define UDF_EXT_VOL_DESC_STD_ID_BOOT_2  'O'
#define UDF_EXT_VOL_DESC_STD_ID_BOOT_3  'T'
#define UDF_EXT_VOL_DESC_STD_ID_BOOT_4  '2'

/** Helper for making a 64-bit header constant from UDF_EXT_VOL_DESC_XXX. */
#define UDF_EXT_VOL_DESC_MAKE_U64_CONST(a_IdMacroPrefix) \
    ISO9660VOLDESC_MAKE_U64_HDR_CONST(UDF_EXT_VOL_DESC_TYPE, a_IdMacroPrefix, UDF_EXT_VOL_DESC_VERSION)


/**
 * Begin UDF extended volume descriptor area (@ecma167{2,9.2,33}).
 */
typedef struct UDFEXTVOLDESCBEGIN
{
    /** The volume descriptor header.
     * The standard identifier is UDF_EXT_VOL_DESC_STD_ID_BEGIN. */
    ISO9660VOLDESCHDR   Hdr;
    /** Zero payload. */
    uint8_t             abZero[2041];
} UDFEXTVOLDESCBEGIN;
AssertCompileSize(UDFEXTVOLDESCBEGIN, 2048);
/** Pointer to an UDF extended volume descriptor indicating the start of the
 * extended descriptor area. */
typedef UDFEXTVOLDESCBEGIN *PUDFEXTVOLDESCBEGIN;
/** Pointer to a const UDF extended volume descriptor indicating the start of
 * the extended descriptor area. */
typedef UDFEXTVOLDESCBEGIN const *PCUDFEXTVOLDESCBEGIN;


/**
 * Terminate UDF extended volume descriptor area (@ecma167{2,9.3,33}).
 */
typedef struct UDFEXTVOLDESCTERM
{
    /** The volume descriptor header.
     * The standard identifier is UDF_EXT_VOL_DESC_STD_ID_TERM. */
    ISO9660VOLDESCHDR   Hdr;
    /** Zero payload. */
    uint8_t             abZero[2041];
} UDFEXTVOLDESCTERM;
AssertCompileSize(UDFEXTVOLDESCTERM, 2048);
/** Pointer to an UDF extended volume descriptor indicating the end of the
 * extended descriptor area. */
typedef UDFEXTVOLDESCTERM *PUDFEXTVOLDESCTERM;
/** Pointer to a const UDF extended volume descriptor indicating the end of
 * the extended descriptor area. */
typedef UDFEXTVOLDESCTERM const *PCUDFEXTVOLDESCTERM;


/**
 * UDF NSR extended volume descriptor (@ecma167{3,9.1,50}).
 *
 * This gives the ECMA standard version.
 */
typedef struct UDFEXTVOLDESCNSR
{
    /** The volume descriptor header.
     * The standard identifier is UDF_EXT_VOL_DESC_STD_ID_NSR_02, or
     * UDF_EXT_VOL_DESC_STD_ID_NSR_03. */
    ISO9660VOLDESCHDR   Hdr;
    /** Zero payload. */
    uint8_t             abZero[2041];
} UDFEXTVOLDESCNSR;
AssertCompileSize(UDFEXTVOLDESCNSR, 2048);
/** Pointer to an extended volume descriptor giving the UDF standard version. */
typedef UDFEXTVOLDESCNSR *PUDFEXTVOLDESCNSR;
/** Pointer to a const extended volume descriptor giving the UDF standard version. */
typedef UDFEXTVOLDESCNSR const *PCUDFEXTVOLDESCNSR;


/**
 * UDF boot extended volume descriptor (@ecma167{2,9.4,34}).
 *
 * @note Probably entirely unused.
 */
typedef struct UDFEXTVOLDESCBOOT
{
    /** 0x00: The volume descriptor header.
     * The standard identifier is UDF_EXT_VOL_DESC_STD_ID_BOOT. */
    ISO9660VOLDESCHDR   Hdr;
    /** 0x07: Reserved/alignment, MBZ. */
    uint8_t             bReserved1;
    /** 0x08: The architecture type. */
    UDFENTITYID         ArchType;
    /** 0x28: The boot identifier. */
    UDFENTITYID         idBoot;
    /** 0x48: Logical sector number of load the boot loader from. */
    uint32_t            offBootExtent;
    /** 0x4c: Number of bytes to load. */
    uint32_t            cbBootExtent;
    /** 0x50: The load address (in memory). */
    uint64_t            uLoadAddress;
    /** 0x58: The start address (in memory). */
    uint64_t            uStartAddress;
    /** 0x60: The descriptor creation timestamp. */
    UDFTIMESTAMP        CreationTimestamp;
    /** 0x6c: Flags. */
    uint16_t            fFlags;
    /** 0x6e: Reserved, MBZ. */
    uint8_t             abReserved2[32];
    /** 0x8e: Implementation use. */
    uint8_t             abBootUse[1906];
} UDFEXTVOLDESCBOOT;
AssertCompileSize(UDFEXTVOLDESCBOOT, 2048);
/** Pointer to a boot extended volume descriptor. */
typedef UDFEXTVOLDESCBOOT *PUDFEXTVOLDESCBOOT;
/** Pointer to a const boot extended volume descriptor. */
typedef UDFEXTVOLDESCBOOT const *PCUDFEXTVOLDESCBOOT;

/** @} */


/** @} */

#endif /* !IPRT_INCLUDED_formats_udf_h */