// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename       : PFI.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Device structures decoders.
//
// --[ Description ] ----------------------------------------------------------
//
//     Records DVD Physical Format Information.
//
// --[ License ] --------------------------------------------------------------
//
//     This library is free software; you can redistribute it and/or modify
//     it under the terms of the GNU Lesser General Public License as
//     published by the Free Software Foundation; either version 2.1 of the
//     License, or (at your option) any later version.
//
//     This library 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
//     Lesser General Public License for more details.
//
//     You should have received a copy of the GNU Lesser General Public
//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/

using System;
using System.Diagnostics.CodeAnalysis;
using System.Text;

namespace DiscImageChef.Decoders.DVD
{
    /// <summary>
    ///     Information from the following standards:
    ///     ANSI X3.304-1997
    ///     T10/1048-D revision 9.0
    ///     T10/1048-D revision 10a
    ///     T10/1228-D revision 7.0c
    ///     T10/1228-D revision 11a
    ///     T10/1363-D revision 10g
    ///     T10/1545-D revision 1d
    ///     T10/1545-D revision 5
    ///     T10/1545-D revision 5a
    ///     T10/1675-D revision 2c
    ///     T10/1675-D revision 4
    ///     T10/1836-D revision 2g
    ///     ECMA 267: 120 mm DVD - Read-Only Disk
    ///     ECMA 268: 80 mm DVD - Read-Only Disk
    ///     ECMA 272: 120 mm DVD Rewritable Disk (DVD-RAM)
    ///     ECMA 274: Data Interchange on 120 mm Optical Disk using +RW Format - Capacity: 3,0 Gbytes and 6,0 Gbytes
    ///     ECMA 279: 80 mm (1,23 Gbytes per side) and 120 mm (3,95 Gbytes per side) DVD-Recordable Disk (DVD-R)
    ///     ECMA 330: 120 mm (4,7 Gbytes per side) and 80 mm (1,46 Gbytes per side) DVD Rewritable Disk (DVD-RAM)
    ///     ECMA 337: Data Interchange on 120 mm and 80 mm Optical Disk using +RW Format - Capacity: 4,7 and 1,46 Gbytes per
    ///     Side
    ///     ECMA 338: 80 mm (1,46 Gbytes per side) and 120 mm (4,70 Gbytes per side) DVD Re-recordable Disk (DVD-RW)
    ///     ECMA 349: Data Interchange on 120 mm and 80 mm Optical Disk using +R Format - Capacity: 4,7 and 1,46 Gbytes per
    ///     Side
    ///     ECMA 359: 80 mm (1,46 Gbytes per side) and 120 mm (4,70 Gbytes per side) DVD Recordable Disk (DVD-R)
    ///     ECMA 364: Data Interchange on 120 mm and 80 mm Optical Disk using +R DL Format - Capacity 8,55 and 2,66 Gbytes per
    ///     Side
    ///     ECMA 365: Data Interchange on 60 mm Read-Only ODC - Capacity: 1,8 Gbytes (UMD™)
    ///     ECMA 371: Data Interchange on 120 mm and 80 mm Optical Disk using +RW HS Format - Capacity 4,7 and 1,46 Gbytes per
    ///     side
    ///     ECMA 374: Data Interchange on 120 mm and 80 mm Optical Disk using +RW DL Format - Capacity 8,55 and 2,66 Gbytes per
    ///     side
    ///     ECMA 382: 120 mm (8,54 Gbytes per side) and 80 mm (2,66 Gbytes per side) DVD Recordable Disk for Dual Layer (DVD-R
    ///     for DL)
    ///     ECMA 384: 120 mm (8,54 Gbytes per side) and 80 mm (2,66 Gbytes per side) DVD Re-recordable Disk for Dual Layer
    ///     (DVD-RW for DL)
    /// </summary>
    [SuppressMessage("ReSharper", "InconsistentNaming")]
    [SuppressMessage("ReSharper", "MemberCanBeInternal")]
    [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
    [SuppressMessage("ReSharper", "NotAccessedField.Global")]
    public static class PFI
    {
        public struct PhysicalFormatInformation
        {
            /// <summary>
            ///     Bytes 0 to 1
            ///     Data length
            /// </summary>
            public ushort DataLength;
            /// <summary>
            ///     Byte 2
            ///     Reserved
            /// </summary>
            public byte Reserved1;
            /// <summary>
            ///     Byte 3
            ///     Reserved
            /// </summary>
            public byte Reserved2;

            #region PFI common to all
            /// <summary>
            ///     Byte 4, bits 7 to 4
            ///     Disk category field
            /// </summary>
            public DiskCategory DiskCategory;
            /// <summary>
            ///     Byte 4, bits 3 to 0
            ///     Media version
            /// </summary>
            public byte PartVersion;
            /// <summary>
            ///     Byte 5, bits 7 to 4
            ///     120mm if 0, 80mm if 1. If UMD (60mm) 0 also. Reserved rest of values
            /// </summary>
            public DVDSize DiscSize;
            /// <summary>
            ///     Byte 5, bits 3 to 0
            ///     Maximum data rate
            /// </summary>
            public MaximumRateField MaximumRate;
            /// <summary>
            ///     Byte 6, bit 7
            ///     Reserved
            /// </summary>
            public bool Reserved3;
            /// <summary>
            ///     Byte 6, bits 6 to 5
            ///     Number of layers
            /// </summary>
            public byte Layers;
            /// <summary>
            ///     Byte 6, bit 4
            ///     Track path
            /// </summary>
            public bool TrackPath;
            /// <summary>
            ///     Byte 6, bits 3 to 0
            ///     Layer type
            /// </summary>
            public LayerTypeFieldMask LayerType;
            /// <summary>
            ///     Byte 7, bits 7 to 4
            ///     Linear density field
            /// </summary>
            public LinearDensityField LinearDensity;
            /// <summary>
            ///     Byte 7, bits 3 to 0
            ///     Track density field
            /// </summary>
            public TrackDensityField TrackDensity;
            /// <summary>
            ///     Bytes 8 to 11
            ///     PSN where Data Area starts
            /// </summary>
            public uint DataAreaStartPSN;
            /// <summary>
            ///     Bytes 12 to 15
            ///     PSN where Data Area ends
            /// </summary>
            public uint DataAreaEndPSN;
            /// <summary>
            ///     Bytes 16 to 19
            ///     PSN where Data Area ends in Layer 0
            /// </summary>
            public uint Layer0EndPSN;
            /// <summary>
            ///     Byte 20, bit 7
            ///     True if BCA exists. GC/Wii discs do not have this bit set, but there is a BCA, making it unreadable in normal DVD
            ///     drives
            /// </summary>
            public bool BCA;
            /// <summary>
            ///     Byte 20, bits 6 to 0
            ///     Reserved
            /// </summary>
            public byte Reserved4;
            #endregion PFI common to all

            #region UMD PFI
            /// <summary>
            ///     Bytes 21 to 22
            ///     UMD only, media attribute, application-defined, part of media specific in rest of discs
            /// </summary>
            public ushort MediaAttribute;
            #endregion UMD PFI

            #region DVD-RAM PFI
            /// <summary>
            ///     Byte 36
            ///     Disc type, respecting case recordability
            /// </summary>
            public DVDRAMDiscType DiscType;
            #endregion DVD-RAM PFI

            #region DVD-RAM PFI, Version 0001b
            /// <summary>
            ///     Byte 52
            ///     Byte 504 in Version 0110b
            ///     Linear velocity, in tenths of m/s
            /// </summary>
            public byte Velocity;
            /// <summary>
            ///     Byte 53
            ///     Byte 505 in Version 0110b
            ///     Read power on disk surface, tenths of mW
            /// </summary>
            public byte ReadPower;
            /// <summary>
            ///     Byte 54
            ///     Byte 507 in Version 0110b
            ///     Peak power on disk surface for recording land tracks
            /// </summary>
            public byte PeakPower;
            /// <summary>
            ///     Byte 55
            ///     Bias power on disk surface for recording land tracks
            /// </summary>
            public byte BiasPower;
            /// <summary>
            ///     Byte 56
            ///     First pulse starting time for recording on land tracks, ns
            /// </summary>
            public byte FirstPulseStart;
            /// <summary>
            ///     Byte 57
            ///     Byte 515 in Version 0110b
            ///     First pulse ending time for recording on land tracks
            /// </summary>
            public byte FirstPulseEnd;
            /// <summary>
            ///     Byte 58
            ///     Byte 518 in Version 0110b
            ///     Multiple-pulse duration time for recording on land tracks
            /// </summary>
            public byte MultiplePulseDuration;
            /// <summary>
            ///     Byte 59
            ///     Byte 519 in Version 0110b
            ///     Last pulse starting time for recording on land tracks
            /// </summary>
            public byte LastPulseStart;
            /// <summary>
            ///     Byte 60
            ///     Las pulse ending time for recording on land tracks
            /// </summary>
            public byte LastPulseEnd;
            /// <summary>
            ///     Byte 61
            ///     Bias power duration for recording on land tracks
            /// </summary>
            public byte BiasPowerDuration;
            /// <summary>
            ///     Byte 62
            ///     Byte 511 on Version 0110b
            ///     Peak power for recording on groove tracks
            /// </summary>
            public byte PeakPowerGroove;
            /// <summary>
            ///     Byte 63
            ///     Bias power for recording on groove tracks
            /// </summary>
            public byte BiasPowerGroove;
            /// <summary>
            ///     Byte 64
            ///     First pulse starting time on groove tracks
            /// </summary>
            public byte FirstPulseStartGroove;
            /// <summary>
            ///     Byte 65
            ///     First pulse ending time on groove tracks
            /// </summary>
            public byte FirstPulseEndGroove;
            /// <summary>
            ///     Byte 66
            ///     Multiple-pulse duration time on groove tracks
            /// </summary>
            public byte MultiplePulseDurationGroove;
            /// <summary>
            ///     Byte 67
            ///     Last pulse starting time on groove tracks
            /// </summary>
            public byte LastPulseStartGroove;
            /// <summary>
            ///     Byte 68
            ///     Last pulse ending time on groove tracks
            /// </summary>
            public byte LastPulseEndGroove;
            /// <summary>
            ///     Byte 69
            ///     Bias power duration for recording on groove tracks
            /// </summary>
            public byte BiasPowerDurationGroove;
            #endregion DVD-RAM PFI, Version 0001b

            #region DVD-R PFI, DVD-RW PFI
            /// <summary>
            ///     Bytes 36 to 39
            ///     Sector number of the first sector of the current Border Out
            /// </summary>
            public uint CurrentBorderOutSector;
            /// <summary>
            ///     Bytes 40 to 43
            ///     Sector number of the first sector of the next Border In
            /// </summary>
            public uint NextBorderInSector;
            #endregion DVD-R PFI, DVD-RW PFI

            #region DVD+RW PFI
            /// <summary>
            ///     Byte 36
            ///     Linear velocities
            ///     0 = CLV from 4,90 m/s to 6,25 m/s
            ///     1 = CAV from 3,02 m/s to 7,35 m/s
            /// </summary>
            public byte RecordingVelocity;
            /// <summary>
            ///     Byte 37
            ///     Maximum read power in milliwatts at maximum velocity
            ///     mW = 20 * (value - 1)
            /// </summary>
            public byte ReadPowerMaxVelocity;
            /// <summary>
            ///     Byte 38
            ///     Indicative value of Ptarget in mW at maximum velocity
            /// </summary>
            public byte PIndMaxVelocity;
            /// <summary>
            ///     Byte 39
            ///     Peak power multiplication factor at maximum velocity
            /// </summary>
            public byte PMaxVelocity;
            /// <summary>
            ///     Byte 40
            ///     Bias1/write power ration at maximum velocity
            /// </summary>
            public byte E1MaxVelocity;
            /// <summary>
            ///     Byte 41
            ///     Bias2/write power ration at maximum velocity
            /// </summary>
            public byte E2MaxVelocity;
            /// <summary>
            ///     Byte 42
            ///     Target value for γ, γtarget at the maximum velocity
            /// </summary>
            public byte YTargetMaxVelocity;
            /// <summary>
            ///     Byte 43
            ///     Maximum read power in milliwatts at reference velocity (4,90 m/s)
            ///     mW = 20 * (value - 1)
            /// </summary>
            public byte ReadPowerRefVelocity;
            /// <summary>
            ///     Byte 44
            ///     Indicative value of Ptarget in mW at reference velocity (4,90 m/s)
            /// </summary>
            public byte PIndRefVelocity;
            /// <summary>
            ///     Byte 45
            ///     Peak power multiplication factor at reference velocity (4,90 m/s)
            /// </summary>
            public byte PRefVelocity;
            /// <summary>
            ///     Byte 46
            ///     Bias1/write power ration at reference velocity (4,90 m/s)
            /// </summary>
            public byte E1RefVelocity;
            /// <summary>
            ///     Byte 47
            ///     Bias2/write power ration at reference velocity (4,90 m/s)
            /// </summary>
            public byte E2RefVelocity;
            /// <summary>
            ///     Byte 48
            ///     Target value for γ, γtarget at the reference velocity (4,90 m/s)
            /// </summary>
            public byte YTargetRefVelocity;
            /// <summary>
            ///     Byte 49
            ///     Maximum read power in milliwatts at minimum velocity
            ///     mW = 20 * (value - 1)
            /// </summary>
            public byte ReadPowerMinVelocity;
            /// <summary>
            ///     Byte 50
            ///     Indicative value of Ptarget in mW at minimum velocity
            /// </summary>
            public byte PIndMinVelocity;
            /// <summary>
            ///     Byte 51
            ///     Peak power multiplication factor at minimum velocity
            /// </summary>
            public byte PMinVelocity;
            /// <summary>
            ///     Byte 52
            ///     Bias1/write power ration at minimum velocity
            /// </summary>
            public byte E1MinVelocity;
            /// <summary>
            ///     Byte 53
            ///     Bias2/write power ration at minimum velocity
            /// </summary>
            public byte E2MinVelocity;
            /// <summary>
            ///     Byte 54
            ///     Target value for γ, γtarget at the minimum velocity
            /// </summary>
            public byte YTargetMinVelocity;
            #endregion DVD+RW PFI

            #region DVD-RAM PFI, version 0110b
            /// <summary>
            ///     Byte 506, bit 7
            ///     Mode of adaptative write pulse control
            /// </summary>
            public bool AdaptativeWritePulseControlFlag;
            /// <summary>
            ///     Byte 508
            ///     Bias power 1 on disk surface for recording land tracks
            /// </summary>
            public byte BiasPower1;
            /// <summary>
            ///     Byte 509
            ///     Bias power 2 on disk surface for recording land tracks
            /// </summary>
            public byte BiasPower2;
            /// <summary>
            ///     Byte 510
            ///     Bias power 3 on disk surface for recording land tracks
            /// </summary>
            public byte BiasPower3;
            /// <summary>
            ///     Byte 512
            ///     Bias power 1 on disk surface for recording groove tracks
            /// </summary>
            public byte BiasPower1Groove;
            /// <summary>
            ///     Byte 513
            ///     Bias power 2 on disk surface for recording groove tracks
            /// </summary>
            public byte BiasPower2Groove;
            /// <summary>
            ///     Byte 514
            ///     Bias power 3 on disk surface for recording groove tracks
            /// </summary>
            public byte BiasPower3Groove;
            /// <summary>
            ///     Byte 516
            ///     First pulse duration
            /// </summary>
            public byte FirstPulseDuration;
            /// <summary>
            ///     Byte 520
            ///     Bias power 2 duration on land tracks at Velocity 1
            /// </summary>
            public byte BiasPower2Duration;
            /// <summary>
            ///     Byte 521
            ///     First pulse start time, at Mark 3T and Leading Space 3T
            /// </summary>
            public byte FirstPulseStart3TSpace3T;
            /// <summary>
            ///     Byte 522
            ///     First pulse start time, at Mark 4T and Leading Space 3T
            /// </summary>
            public byte FirstPulseStart4TSpace3T;
            /// <summary>
            ///     Byte 523
            ///     First pulse start time, at Mark 5T and Leading Space 3T
            /// </summary>
            public byte FirstPulseStart5TSpace3T;
            /// <summary>
            ///     Byte 524
            ///     First pulse start time, at Mark >5T and Leading Space 3T
            /// </summary>
            public byte FirstPulseStartSpace3T;
            /// <summary>
            ///     Byte 525
            ///     First pulse start time, at Mark 3T and Leading Space 4T
            /// </summary>
            public byte FirstPulseStart3TSpace4T;
            /// <summary>
            ///     Byte 526
            ///     First pulse start time, at Mark 4T and Leading Space 4T
            /// </summary>
            public byte FirstPulseStart4TSpace4T;
            /// <summary>
            ///     Byte 527
            ///     First pulse start time, at Mark 5T and Leading Space 4T
            /// </summary>
            public byte FirstPulseStart5TSpace4T;
            /// <summary>
            ///     Byte 528
            ///     First pulse start time, at Mark >5T and Leading Space 4T
            /// </summary>
            public byte FirstPulseStartSpace4T;
            /// <summary>
            ///     Byte 529
            ///     First pulse start time, at Mark 3T and Leading Space 5T
            /// </summary>
            public byte FirstPulseStart3TSpace5T;
            /// <summary>
            ///     Byte 530
            ///     First pulse start time, at Mark 4T and Leading Space 5T
            /// </summary>
            public byte FirstPulseStart4TSpace5T;
            /// <summary>
            ///     Byte 531
            ///     First pulse start time, at Mark 5T and Leading Space 5T
            /// </summary>
            public byte FirstPulseStart5TSpace5T;
            /// <summary>
            ///     Byte 532
            ///     First pulse start time, at Mark >5T and Leading Space 5T
            /// </summary>
            public byte FirstPulseStartSpace5T;
            /// <summary>
            ///     Byte 533
            ///     First pulse start time, at Mark 3T and Leading Space >5T
            /// </summary>
            public byte FirstPulseStart3TSpace;
            /// <summary>
            ///     Byte 534
            ///     First pulse start time, at Mark 4T and Leading Space >5T
            /// </summary>
            public byte FirstPulseStart4TSpace;
            /// <summary>
            ///     Byte 535
            ///     First pulse start time, at Mark 5T and Leading Space >5T
            /// </summary>
            public byte FirstPulseStart5TSpace;
            /// <summary>
            ///     Byte 536
            ///     First pulse start time, at Mark >5T and Leading Space >5T
            /// </summary>
            public byte FirstPulseStartSpace;
            /// <summary>
            ///     Byte 537
            ///     First pulse start time, at Mark 3T and Trailing Space 3T
            /// </summary>
            public byte FirstPulse3TStartTSpace3T;
            /// <summary>
            ///     Byte 538
            ///     First pulse start time, at Mark 4T and Trailing Space 3T
            /// </summary>
            public byte FirstPulse4TStartTSpace3T;
            /// <summary>
            ///     Byte 539
            ///     First pulse start time, at Mark 5T and Trailing Space 3T
            /// </summary>
            public byte FirstPulse5TStartTSpace3T;
            /// <summary>
            ///     Byte 540
            ///     First pulse start time, at Mark >5T and Trailing Space 3T
            /// </summary>
            public byte FirstPulseStartTSpace3T;
            /// <summary>
            ///     Byte 541
            ///     First pulse start time, at Mark 3T and Trailing Space 4T
            /// </summary>
            public byte FirstPulse3TStartTSpace4T;
            /// <summary>
            ///     Byte 542
            ///     First pulse start time, at Mark 4T and Trailing Space 4T
            /// </summary>
            public byte FirstPulse4TStartTSpace4T;
            /// <summary>
            ///     Byte 543
            ///     First pulse start time, at Mark 5T and Trailing Space 4T
            /// </summary>
            public byte FirstPulse5TStartTSpace4T;
            /// <summary>
            ///     Byte 544
            ///     First pulse start time, at Mark >5T and Trailing Space 4T
            /// </summary>
            public byte FirstPulseStartTSpace4T;
            /// <summary>
            ///     Byte 545
            ///     First pulse start time, at Mark 3T and Trailing Space 5T
            /// </summary>
            public byte FirstPulse3TStartTSpace5T;
            /// <summary>
            ///     Byte 546
            ///     First pulse start time, at Mark 4T and Trailing Space 5T
            /// </summary>
            public byte FirstPulse4TStartTSpace5T;
            /// <summary>
            ///     Byte 547
            ///     First pulse start time, at Mark 5T and Trailing Space 5T
            /// </summary>
            public byte FirstPulse5TStartTSpace5T;
            /// <summary>
            ///     Byte 548
            ///     First pulse start time, at Mark >5T and Trailing Space 5T
            /// </summary>
            public byte FirstPulseStartTSpace5T;
            /// <summary>
            ///     Byte 549
            ///     First pulse start time, at Mark 3T and Trailing Space >5T
            /// </summary>
            public byte FirstPulse3TStartTSpace;
            /// <summary>
            ///     Byte 550
            ///     First pulse start time, at Mark 4T and Trailing Space >5T
            /// </summary>
            public byte FirstPulse4TStartTSpace;
            /// <summary>
            ///     Byte 551
            ///     First pulse start time, at Mark 5T and Trailing Space >5T
            /// </summary>
            public byte FirstPulse5TStartTSpace;
            /// <summary>
            ///     Byte 552
            ///     First pulse start time, at Mark >5T and Trailing Space >5T
            /// </summary>
            public byte FirstPulseStartTSpace;
            /// <summary>
            ///     Bytes 553 to 600
            ///     Disk manufacturer's name, space-padded
            /// </summary>
            public string DiskManufacturer;
            /// <summary>
            ///     Bytes 601 to 616
            ///     Disk manufacturer's supplementary information
            /// </summary>
            public string DiskManufacturerSupplementary;
            /// <summary>
            ///     Bytes 617 to 627
            ///     Write power control parameters
            /// </summary>
            public byte[] WritePowerControlParams;
            /// <summary>
            ///     Byte 619
            ///     Ratio of peak power for land tracks to threshold peak power for land tracks
            /// </summary>
            public byte PowerRatioLandThreshold;
            /// <summary>
            ///     Byte 620
            ///     Target asymmetry
            /// </summary>
            public byte TargetAsymmetry;
            /// <summary>
            ///     Byte 621
            ///     Temporary peak power
            /// </summary>
            public byte TemporaryPeakPower;
            /// <summary>
            ///     Byte 622
            ///     Temporary bias power 1
            /// </summary>
            public byte TemporaryBiasPower1;
            /// <summary>
            ///     Byte 623
            ///     Temporary bias power 2
            /// </summary>
            public byte TemporaryBiasPower2;
            /// <summary>
            ///     Byte 624
            ///     Temporary bias power 3
            /// </summary>
            public byte TemporaryBiasPower3;
            /// <summary>
            ///     Byte 625
            ///     Ratio of peak power for groove tracks to threshold peak power for groove tracks
            /// </summary>
            public byte PowerRatioGrooveThreshold;
            /// <summary>
            ///     Byte 626
            ///     Ratio of peak power for land tracks to threshold 6T peak power for land tracks
            /// </summary>
            public byte PowerRatioLandThreshold6T;
            /// <summary>
            ///     Byte 627
            ///     Ratio of peak power for groove tracks to threshold 6T peak power for groove tracks
            /// </summary>
            public byte PowerRatioGrooveThreshold6T;
            #endregion DVD-RAM PFI, version 0110b

            #region DVD+RW PFI, DVD+R PFI, DVD+R DL PFI and DVD+RW DL PFI
            /// <summary>
            ///     Byte 20, bit 6
            ///     If set indicates data zone contains extended information for VCPS
            /// </summary>
            public bool VCPS;
            /// <summary>
            ///     Byte 21
            ///     Indicates restricted usage disk
            /// </summary>
            public byte ApplicationCode;
            /// <summary>
            ///     Byte 22
            ///     Bitmap of extended information block presence
            /// </summary>
            public byte ExtendedInformation;
            /// <summary>
            ///     Bytes 23 to 30
            ///     Disk manufacturer ID, null-padded
            /// </summary>
            public string DiskManufacturerID;
            /// <summary>
            ///     Bytes 31 to 33
            ///     Media type ID, null-padded
            /// </summary>
            public string MediaTypeID;
            /// <summary>
            ///     Byte 34
            ///     Product revision number
            /// </summary>
            public byte ProductRevision;
            /// <summary>
            ///     Byte 35
            ///     Indicates how many bytes, up to 63, are used in ADIP's PFI
            /// </summary>
            public byte PFIUsedInADIP;
            #endregion DVD+RW PFI, DVD+R PFI, DVD+R DL PFI and DVD+RW DL PFI

            #region DVD+RW PFI, version 0010b
            /// <summary>
            ///     Byte 55
            ///     Ttop first pulse duration
            /// </summary>
            public byte TopFirstPulseDuration;
            /// <summary>
            ///     Byte 56
            ///     Tmp multi pulse duration
            /// </summary>
            public byte MultiPulseDuration;
            /// <summary>
            ///     Byte 57
            ///     dTtop first pulse lead time
            /// </summary>
            public byte FirstPulseLeadTime;
            /// <summary>
            ///     Byte 58
            ///     dTera erase lead time at reference velocity
            /// </summary>
            public byte EraseLeadTimeRefVelocity;
            /// <summary>
            ///     Byte 59
            ///     dTera erase lead time at upper velocity
            /// </summary>
            public byte EraseLeadTimeUppVelocity;
            #endregion DVD+RW PFI, version 0010b

            #region DVD+R PFI version 0001b and DVD+R DL PFI version 0001b
            /// <summary>
            ///     Byte 36
            ///     Primary recording velocity for the basic write strategy
            /// </summary>
            public byte PrimaryVelocity;
            /// <summary>
            ///     Byte 37
            ///     Upper recording velocity for the basic write strategy
            /// </summary>
            public byte UpperVelocity;
            /// <summary>
            ///     Byte 38
            ///     Wavelength λIND
            /// </summary>
            public byte Wavelength;
            /// <summary>
            ///     Byte 39
            ///     Normalized write power dependency on wavelength (dP/dλ)/(PIND/λIND)
            /// </summary>
            public byte NormalizedPowerDependency;
            /// <summary>
            ///     Byte 40
            ///     Maximum read power at primary velocity
            /// </summary>
            public byte MaximumPowerAtPrimaryVelocity;
            /// <summary>
            ///     Byte 41
            ///     Pind at primary velocity
            /// </summary>
            public byte PindAtPrimaryVelocity;
            /// <summary>
            ///     Byte 42
            ///     βtarget at primary velocity
            /// </summary>
            public byte BtargetAtPrimaryVelocity;
            /// <summary>
            ///     Byte 43
            ///     Maximum read power at upper velocity
            /// </summary>
            public byte MaximumPowerAtUpperVelocity;
            /// <summary>
            ///     Byte 44
            ///     Pind at primary velocity
            /// </summary>
            public byte PindAtUpperVelocity;
            /// <summary>
            ///     Byte 45
            ///     βtarget at upper velocity
            /// </summary>
            public byte BtargetAtUpperVelocity;
            /// <summary>
            ///     Byte 46
            ///     Ttop (≥4T) first pulse duration for cm∗ ≥4T at Primary velocity
            /// </summary>
            public byte FirstPulseDuration4TPrimaryVelocity;
            /// <summary>
            ///     Byte 47
            ///     Ttop (=3T) first pulse duration for cm∗ =3T at Primary velocity
            /// </summary>
            public byte FirstPulseDuration3TPrimaryVelocity;
            /// <summary>
            ///     Byte 48
            ///     Tmp multi pulse duration at Primary velocity
            /// </summary>
            public byte MultiPulseDurationPrimaryVelocity;
            /// <summary>
            ///     Byte 49
            ///     Tlp last pulse duration at Primary velocity
            /// </summary>
            public byte LastPulseDurationPrimaryVelocity;
            /// <summary>
            ///     Byte 50
            ///     dTtop (≥4T) first pulse lead time for cm∗ ≥4T at Primary velocity
            /// </summary>
            public byte FirstPulseLeadTime4TPrimaryVelocity;
            /// <summary>
            ///     Byte 51
            ///     dTtop (=3T) first pulse lead time for cm∗ =3T at Primary velocity
            /// </summary>
            public byte FirstPulseLeadTime3TPrimaryVelocity;
            /// <summary>
            ///     Byte 52
            ///     dTle first pulse leading edge shift for ps∗ =3T at Primary velocity
            /// </summary>
            public byte FirstPulseLeadingEdgePrimaryVelocity;
            /// <summary>
            ///     Byte 53
            ///     Ttop (≥4T) first pulse duration for cm∗ ≥4T at Upper velocity
            /// </summary>
            public byte FirstPulseDuration4TUpperVelocity;
            /// <summary>
            ///     Byte 54
            ///     Ttop (=3T) first pulse duration for cm∗ =3T at Upper velocity
            /// </summary>
            public byte FirstPulseDuration3TUpperVelocity;
            /// <summary>
            ///     Byte 55
            ///     Tmp multi pulse duration at Upper velocity
            /// </summary>
            public byte MultiPulseDurationUpperVelocity;
            /// <summary>
            ///     Byte 56
            ///     Tlp last pulse duration at Upper velocity
            /// </summary>
            public byte LastPulseDurationUpperVelocity;
            /// <summary>
            ///     Byte 57
            ///     dTtop (≥4T) first pulse lead time for cm∗ ≥4T at Upper velocity
            /// </summary>
            public byte FirstPulseLeadTime4TUpperVelocity;
            /// <summary>
            ///     Byte 58
            ///     dTtop (=3T) first pulse lead time for cm∗ =3T at Upper velocity
            /// </summary>
            public byte FirstPulseLeadTime3TUpperVelocity;
            /// <summary>
            ///     Byte 59
            ///     dTle first pulse leading edge shift for ps∗ =3T at Upper velocity
            /// </summary>
            public byte FirstPulseLeadingEdgeUpperVelocity;
            #endregion DVD+R PFI version 0001b and DVD+R DL PFI version 0001b

            #region DVD+R DL PFI version 0001b
            /// <summary>
            ///     Byte 34, bits 7 to 6
            /// </summary>
            public DVDLayerStructure LayerStructure;
            #endregion DVD+R DL PFI version 0001b

            #region DVD+RW DL PFI
            /// <summary>
            ///     Byte 36
            ///     Primary recording velocity for the basic write strategy
            /// </summary>
            public byte BasicPrimaryVelocity;
            /// <summary>
            ///     Byte 37
            ///     Maximum read power at Primary velocity
            /// </summary>
            public byte MaxReadPowerPrimaryVelocity;
            /// <summary>
            ///     Byte 38
            ///     PIND at Primary velocity
            /// </summary>
            public byte PindPrimaryVelocity;
            /// <summary>
            ///     Byte 39
            ///     ρ at Primary velocity
            /// </summary>
            public byte PPrimaryVelocity;
            /// <summary>
            ///     Byte 40
            ///     ε1 at Primary velocity
            /// </summary>
            public byte E1PrimaryVelocity;
            /// <summary>
            ///     Byte 41
            ///     ε2 at Primary velocity
            /// </summary>
            public byte E2PrimaryVelocity;
            /// <summary>
            ///     Byte 42
            ///     γtarget at Primary velocity
            /// </summary>
            public byte YtargetPrimaryVelocity;
            /// <summary>
            ///     Byte 43
            ///     β optimum at Primary velocity
            /// </summary>
            public byte BOptimumPrimaryVelocity;
            /// <summary>
            ///     Byte 46
            ///     Ttop first pulse duration
            /// </summary>
            public byte TFirstPulseDuration;
            /// <summary>
            ///     Byte 47
            ///     Tmp multi pulse duration
            /// </summary>
            public byte TMultiPulseDuration;
            /// <summary>
            ///     Byte 48
            ///     dTtop first pulse lead/lag time for any runlength ≥ 4T
            /// </summary>
            public byte FirstPulseLeadTimeAnyRun;
            /// <summary>
            ///     Byte 49
            ///     dTtop,3 first pulse lead/lag time for runlengths = 3T
            /// </summary>
            public byte FirstPulseLeadTimeRun3T;
            /// <summary>
            ///     Byte 50
            ///     dTlp last pulse lead/lag time for any runlength ≥ 5T
            /// </summary>
            public byte LastPulseLeadTimeAnyRun;
            /// <summary>
            ///     Byte 51
            ///     dTlp,3 last pulse lead/lag time for runlengths = 3T
            /// </summary>
            public byte LastPulseLeadTime3T;
            /// <summary>
            ///     Byte 52
            ///     dTlp,4 last pulse lead/lag time for runlengths = 4T
            /// </summary>
            public byte LastPulseLeadTime4T;
            /// <summary>
            ///     Byte 53
            ///     dTera erase lead/lag time when preceding mark length ≥ 5T
            /// </summary>
            public byte ErasePulseLeadTimeAny;
            /// <summary>
            ///     Byte 54
            ///     dTera,3 erase lead/lag time when preceding mark length = 3T
            /// </summary>
            public byte ErasePulseLeadTime3T;
            /// <summary>
            ///     Byte 55
            ///     dTera,4 erase lead/lag time when preceding mark length = 4T
            /// </summary>
            public byte ErasePulseLeadTime4T;
            #endregion DVD+RW DL PFI

            #region DVD-R DL PFI and DVD-RW DL PFI
            /// <summary>
            ///     Byte 21
            ///     Maximum recording speed
            /// </summary>
            public DVDRecordingSpeed MaxRecordingSpeed;
            /// <summary>
            ///     Byte 22
            ///     Minimum recording speed
            /// </summary>
            public DVDRecordingSpeed MinRecordingSpeed;
            /// <summary>
            ///     Byte 23
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed1;
            /// <summary>
            ///     Byte 24
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed2;
            /// <summary>
            ///     Byte 25
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed3;
            /// <summary>
            ///     Byte 26
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed4;
            /// <summary>
            ///     Byte 27
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed5;
            /// <summary>
            ///     Byte 28
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed6;
            /// <summary>
            ///     Byte 29
            ///     Another recording speed
            /// </summary>
            public DVDRecordingSpeed RecordingSpeed7;
            /// <summary>
            ///     Byte 30
            ///     Class
            /// </summary>
            public byte Class;
            /// <summary>
            ///     Byte 31
            ///     Extended version. 0x30 = ECMA-382, 0x20 = ECMA-384
            /// </summary>
            public byte ExtendedVersion;
            /// <summary>
            ///     Byte 36
            ///     Start sector number of current RMD in Extra Border Zone
            /// </summary>
            public uint CurrentRMDExtraBorderPSN;
            /// <summary>
            ///     Byte 40
            ///     Start sector number of Physical Format Information blocks in Extra Border Zone
            /// </summary>
            public uint PFIExtraBorderPSN;
            /// <summary>
            ///     Byte 44, bit 0
            ///     If NOT set, Control Data Zone is pre-recorded
            /// </summary>
            public bool PreRecordedControlDataInv;
            /// <summary>
            ///     Byte 44 bit 1
            ///     Lead-in Zone is pre-recorded
            /// </summary>
            public bool PreRecordedLeadIn;
            /// <summary>
            ///     Byte 44 bit 3
            ///     Lead-out Zone is pre-recorded
            /// </summary>
            public bool PreRecordedLeadOut;
            /// <summary>
            ///     Byte 45 bits 0 to 3
            ///     AR characteristic of LPP on Layer 1
            /// </summary>
            public byte ARCharLayer1;
            /// <summary>
            ///     Byte 45 bits 4 to 7
            ///     Tracking polarity on Layer 1
            /// </summary>
            public byte TrackPolarityLayer1;
            #endregion DVD-R DL PFI and DVD-RW DL PFI
        }

        public static PhysicalFormatInformation? Decode(byte[] response)
        {
            if(response == null) return null;

            if(response.Length == 2048)
            {
                byte[] tmp2 = new byte[2052];
                Array.Copy(response, 0, tmp2, 4, 2048);
                response = tmp2;
            }

            if(response.Length < 2052) return null;

            PhysicalFormatInformation pfi = new PhysicalFormatInformation();
            byte[]                    tmp;

            pfi.DataLength = (ushort)((response[0] << 8) + response[1]);
            pfi.Reserved1  = response[2];
            pfi.Reserved2  = response[3];

            // Common
            pfi.DiskCategory  =  (DiskCategory)((response[4] & 0xF0) >> 4);
            pfi.PartVersion   =  (byte)(response[4] & 0x0F);
            pfi.DiscSize      =  (DVDSize)((response[5] & 0xF0) >> 4);
            pfi.MaximumRate   =  (MaximumRateField)(response[5] & 0x0F);
            pfi.Reserved3     |= (response[6]                   & 0x80) == 0x80;
            pfi.Layers        =  (byte)((response[6] & 0x60) >> 5);
            pfi.TrackPath     |= (response[6]                     & 0x08) == 0x08;
            pfi.LayerType     =  (LayerTypeFieldMask)(response[6] & 0x07);
            pfi.LinearDensity =  (LinearDensityField)((response[7] & 0xF0) >> 4);
            pfi.TrackDensity  =  (TrackDensityField)(response[7] & 0x0F);
            pfi.DataAreaStartPSN =
                (uint)((response[8] << 24) + (response[9] << 16) + (response[10] << 8) + response[11]);
            pfi.DataAreaEndPSN =
                (uint)((response[12] << 24) + (response[13] << 16) + (response[14] << 8) + response[15]);
            pfi.Layer0EndPSN =
                (uint)((response[16] << 24) + (response[17] << 16) + (response[18] << 8) + response[19]);
            pfi.BCA |= (response[20] & 0x80) == 0x80;

            switch(pfi.DiskCategory)
            {
                // UMD
                case DiskCategory.UMD:
                    pfi.MediaAttribute = (ushort)((response[21] << 8) + response[22]);
                    break;
                // DVD-RAM
                case DiskCategory.DVDRAM:
                    pfi.DiscType = (DVDRAMDiscType)response[36];

                    if(pfi.PartVersion == 1)
                    {
                        pfi.Velocity                    = response[52];
                        pfi.ReadPower                   = response[53];
                        pfi.PeakPower                   = response[54];
                        pfi.BiasPower                   = response[55];
                        pfi.FirstPulseStart             = response[56];
                        pfi.FirstPulseEnd               = response[57];
                        pfi.MultiPulseDuration          = response[58];
                        pfi.LastPulseStart              = response[59];
                        pfi.LastPulseEnd                = response[60];
                        pfi.BiasPowerDuration           = response[61];
                        pfi.PeakPowerGroove             = response[62];
                        pfi.BiasPowerGroove             = response[63];
                        pfi.FirstPulseStartGroove       = response[64];
                        pfi.FirstPulseEndGroove         = response[65];
                        pfi.MultiplePulseDurationGroove = response[66];
                        pfi.LastPulseStartGroove        = response[67];
                        pfi.LastPulseEndGroove          = response[68];
                        pfi.BiasPowerDurationGroove     = response[69];
                    }
                    else if(pfi.PartVersion == 6)
                    {
                        pfi.Velocity                        =  response[504];
                        pfi.ReadPower                       =  response[505];
                        pfi.AdaptativeWritePulseControlFlag |= (response[506] & 0x80) == 0x80;
                        pfi.PeakPower                       =  response[507];
                        pfi.BiasPower1                      =  response[508];
                        pfi.BiasPower2                      =  response[509];
                        pfi.BiasPower3                      =  response[510];
                        pfi.PeakPowerGroove                 =  response[511];
                        pfi.BiasPower1Groove                =  response[512];
                        pfi.BiasPower2Groove                =  response[513];
                        pfi.BiasPower3Groove                =  response[514];
                        pfi.FirstPulseEnd                   =  response[515];
                        pfi.FirstPulseDuration              =  response[516];
                        pfi.MultiPulseDuration              =  response[518];
                        pfi.LastPulseStart                  =  response[519];
                        pfi.BiasPower2Duration              =  response[520];
                        pfi.FirstPulseStart3TSpace3T        =  response[521];
                        pfi.FirstPulseStart4TSpace3T        =  response[522];
                        pfi.FirstPulseStart5TSpace3T        =  response[523];
                        pfi.FirstPulseStartSpace3T          =  response[524];
                        pfi.FirstPulseStart3TSpace4T        =  response[525];
                        pfi.FirstPulseStart4TSpace4T        =  response[526];
                        pfi.FirstPulseStart5TSpace4T        =  response[527];
                        pfi.FirstPulseStartSpace4T          =  response[528];
                        pfi.FirstPulseStart3TSpace5T        =  response[529];
                        pfi.FirstPulseStart4TSpace5T        =  response[530];
                        pfi.FirstPulseStart5TSpace5T        =  response[531];
                        pfi.FirstPulseStartSpace5T          =  response[532];
                        pfi.FirstPulseStart3TSpace          =  response[533];
                        pfi.FirstPulseStart4TSpace          =  response[534];
                        pfi.FirstPulseStart5TSpace          =  response[535];
                        pfi.FirstPulseStartSpace            =  response[536];
                        pfi.FirstPulse3TStartTSpace3T       =  response[537];
                        pfi.FirstPulse4TStartTSpace3T       =  response[538];
                        pfi.FirstPulse5TStartTSpace3T       =  response[539];
                        pfi.FirstPulseStartTSpace3T         =  response[540];
                        pfi.FirstPulse3TStartTSpace4T       =  response[541];
                        pfi.FirstPulse4TStartTSpace4T       =  response[542];
                        pfi.FirstPulse5TStartTSpace4T       =  response[543];
                        pfi.FirstPulseStartTSpace4T         =  response[544];
                        pfi.FirstPulse3TStartTSpace5T       =  response[545];
                        pfi.FirstPulse4TStartTSpace5T       =  response[546];
                        pfi.FirstPulse5TStartTSpace5T       =  response[547];
                        pfi.FirstPulseStartTSpace5T         =  response[548];
                        pfi.FirstPulse3TStartTSpace         =  response[549];
                        pfi.FirstPulse4TStartTSpace         =  response[550];
                        pfi.FirstPulse5TStartTSpace         =  response[551];
                        pfi.FirstPulseStartTSpace           =  response[552];
                        tmp                                 =  new byte[48];
                        Array.Copy(response, 553, tmp, 0, 48);
                        pfi.DiskManufacturer = StringHandlers.SpacePaddedToString(tmp);
                        tmp                  = new byte[16];
                        Array.Copy(response, 601, tmp, 0, 16);
                        pfi.DiskManufacturerSupplementary = StringHandlers.SpacePaddedToString(tmp);
                        pfi.WritePowerControlParams       = new byte[2];
                        pfi.WritePowerControlParams[0]    = response[617];
                        pfi.WritePowerControlParams[1]    = response[618];
                        pfi.PowerRatioLandThreshold       = response[619];
                        pfi.TargetAsymmetry               = response[620];
                        pfi.TemporaryPeakPower            = response[621];
                        pfi.TemporaryBiasPower1           = response[622];
                        pfi.TemporaryBiasPower2           = response[623];
                        pfi.TemporaryBiasPower3           = response[624];
                        pfi.PowerRatioGrooveThreshold     = response[625];
                        pfi.PowerRatioLandThreshold6T     = response[626];
                        pfi.PowerRatioGrooveThreshold6T   = response[627];
                    }

                    break;
                // DVD-R and DVD-RW
                case DiskCategory.DVDR when pfi.PartVersion  < 6:
                case DiskCategory.DVDRW when pfi.PartVersion < 3:
                    pfi.CurrentBorderOutSector =
                        (uint)((response[36] << 24) + (response[37] << 16) + (response[38] << 8) + response[39]);
                    pfi.NextBorderInSector =
                        (uint)((response[40] << 24) + (response[41] << 16) + (response[42] << 8) + response[43]);
                    break;
                // DVD+RW
                case DiskCategory.DVDPRW:
                    pfi.RecordingVelocity    = response[36];
                    pfi.ReadPowerMaxVelocity = response[37];
                    pfi.PIndMaxVelocity      = response[38];
                    pfi.PMaxVelocity         = response[39];
                    pfi.E1MaxVelocity        = response[40];
                    pfi.E2MaxVelocity        = response[41];
                    pfi.YTargetMaxVelocity   = response[42];
                    pfi.ReadPowerRefVelocity = response[43];
                    pfi.PIndRefVelocity      = response[44];
                    pfi.PRefVelocity         = response[45];
                    pfi.E1RefVelocity        = response[46];
                    pfi.E2RefVelocity        = response[47];
                    pfi.YTargetRefVelocity   = response[48];
                    pfi.ReadPowerMinVelocity = response[49];
                    pfi.PIndMinVelocity      = response[50];
                    pfi.PMinVelocity         = response[51];
                    pfi.E1MinVelocity        = response[52];
                    pfi.E2MinVelocity        = response[53];
                    pfi.YTargetMinVelocity   = response[54];
                    break;
            }

            // DVD+R, DVD+RW, DVD+R DL and DVD+RW DL
            if(pfi.DiskCategory == DiskCategory.DVDPR   || pfi.DiskCategory == DiskCategory.DVDPRW ||
               pfi.DiskCategory == DiskCategory.DVDPRDL || pfi.DiskCategory == DiskCategory.DVDPRWDL)
            {
                pfi.VCPS                |= (response[20] & 0x40) == 0x40;
                pfi.ApplicationCode     =  response[21];
                pfi.ExtendedInformation =  response[22];
                tmp                     =  new byte[8];
                Array.Copy(response, 23, tmp, 0, 8);
                pfi.DiskManufacturerID = StringHandlers.CToString(tmp);
                tmp                    = new byte[3];
                Array.Copy(response, 31, tmp, 0, 3);
                pfi.MediaTypeID = StringHandlers.CToString(tmp);
                pfi.ProductRevision =
                    pfi.DiskCategory == DiskCategory.DVDPRDL ? (byte)(response[34] & 0x3F) : response[34];
                pfi.PFIUsedInADIP = response[35];
            }

            switch(pfi.DiskCategory)
            {
                // DVD+RW
                case DiskCategory.DVDPRW when pfi.PartVersion == 2:
                    pfi.TopFirstPulseDuration    = response[55];
                    pfi.MultiPulseDuration       = response[56];
                    pfi.FirstPulseLeadTime       = response[57];
                    pfi.EraseLeadTimeRefVelocity = response[58];
                    pfi.EraseLeadTimeUppVelocity = response[59];
                    break;
                // DVD+R and DVD+R DL
                case DiskCategory.DVDPR:
                case DiskCategory.DVDPRDL:
                    pfi.PrimaryVelocity                      = response[36];
                    pfi.UpperVelocity                        = response[37];
                    pfi.Wavelength                           = response[38];
                    pfi.NormalizedPowerDependency            = response[39];
                    pfi.MaximumPowerAtPrimaryVelocity        = response[40];
                    pfi.PindAtPrimaryVelocity                = response[41];
                    pfi.BtargetAtPrimaryVelocity             = response[42];
                    pfi.MaximumPowerAtUpperVelocity          = response[43];
                    pfi.PindAtUpperVelocity                  = response[44];
                    pfi.BtargetAtUpperVelocity               = response[45];
                    pfi.FirstPulseDuration4TPrimaryVelocity  = response[46];
                    pfi.FirstPulseDuration3TPrimaryVelocity  = response[47];
                    pfi.MultiPulseDurationPrimaryVelocity    = response[48];
                    pfi.LastPulseDurationPrimaryVelocity     = response[49];
                    pfi.FirstPulseLeadTime4TPrimaryVelocity  = response[50];
                    pfi.FirstPulseLeadTime3TPrimaryVelocity  = response[51];
                    pfi.FirstPulseLeadingEdgePrimaryVelocity = response[52];
                    pfi.FirstPulseDuration4TUpperVelocity    = response[53];
                    pfi.FirstPulseDuration3TUpperVelocity    = response[54];
                    pfi.MultiPulseDurationUpperVelocity      = response[55];
                    pfi.LastPulseDurationUpperVelocity       = response[56];
                    pfi.FirstPulseLeadTime4TUpperVelocity    = response[57];
                    pfi.FirstPulseLeadTime3TUpperVelocity    = response[58];
                    pfi.FirstPulseLeadingEdgeUpperVelocity   = response[59];
                    break;
            }

            switch(pfi.DiskCategory)
            {
                // DVD+R DL
                case DiskCategory.DVDPRDL:
                    pfi.LayerStructure = (DVDLayerStructure)((response[34] & 0xC0) >> 6);
                    break;
                // DVD+RW DL
                case DiskCategory.DVDPRWDL:
                    pfi.BasicPrimaryVelocity        = response[36];
                    pfi.MaxReadPowerPrimaryVelocity = response[37];
                    pfi.PindPrimaryVelocity         = response[38];
                    pfi.PPrimaryVelocity            = response[39];
                    pfi.E1PrimaryVelocity           = response[40];
                    pfi.E2PrimaryVelocity           = response[41];
                    pfi.YtargetPrimaryVelocity      = response[42];
                    pfi.BOptimumPrimaryVelocity     = response[43];
                    pfi.TFirstPulseDuration         = response[46];
                    pfi.TMultiPulseDuration         = response[47];
                    pfi.FirstPulseLeadTimeAnyRun    = response[48];
                    pfi.FirstPulseLeadTimeRun3T     = response[49];
                    pfi.LastPulseLeadTimeAnyRun     = response[50];
                    pfi.LastPulseLeadTime3T         = response[51];
                    pfi.LastPulseLeadTime4T         = response[52];
                    pfi.ErasePulseLeadTimeAny       = response[53];
                    pfi.ErasePulseLeadTime3T        = response[54];
                    pfi.ErasePulseLeadTime4T        = response[55];
                    break;
                // DVD-R DL and DVD-RW DL
                case DiskCategory.DVDR when pfi.PartVersion  == 6:
                case DiskCategory.DVDRW when pfi.PartVersion == 3:
                    pfi.MaxRecordingSpeed = (DVDRecordingSpeed)response[21];
                    pfi.MinRecordingSpeed = (DVDRecordingSpeed)response[22];
                    pfi.RecordingSpeed1   = (DVDRecordingSpeed)response[23];
                    pfi.RecordingSpeed2   = (DVDRecordingSpeed)response[24];
                    pfi.RecordingSpeed3   = (DVDRecordingSpeed)response[25];
                    pfi.RecordingSpeed4   = (DVDRecordingSpeed)response[26];
                    pfi.RecordingSpeed5   = (DVDRecordingSpeed)response[27];
                    pfi.RecordingSpeed6   = (DVDRecordingSpeed)response[28];
                    pfi.RecordingSpeed7   = (DVDRecordingSpeed)response[29];
                    pfi.Class             = response[30];
                    pfi.ExtendedVersion   = response[31];
                    pfi.CurrentBorderOutSector =
                        (uint)((response[36] << 24) + (response[37] << 16) + (response[38] << 8) + response[39]);
                    pfi.NextBorderInSector =
                        (uint)((response[40] << 24) + (response[41] << 16) + (response[42] << 8) + response[43]);
                    pfi.PreRecordedControlDataInv |= (response[44]       & 0x01) == 0x01;
                    pfi.PreRecordedLeadIn         |= (response[44]       & 0x02) == 0x02;
                    pfi.PreRecordedLeadOut        |= (response[44]       & 0x08) == 0x08;
                    pfi.ARCharLayer1              =  (byte)(response[45] & 0x0F);
                    pfi.TrackPolarityLayer1       =  (byte)((response[45] & 0xF0) >> 4);
                    break;
            }

            return pfi;
        }

        public static string Prettify(PhysicalFormatInformation? pfi)
        {
            if(pfi == null) return null;

            PhysicalFormatInformation decoded = pfi.Value;
            StringBuilder             sb      = new StringBuilder();

            string sizeString;
            switch(decoded.DiscSize)
            {
                case DVDSize.Eighty:
                    sizeString = "80mm";
                    break;
                case DVDSize.OneTwenty:
                    sizeString = "120mm";
                    break;
                default:
                    sizeString = $"unknown size identifier {decoded.DiscSize}";
                    break;
            }

            string categorySentence = "Disc is a {0} {1} version {2}";

            switch(decoded.DiskCategory)
            {
                case DiskCategory.DVDROM:
                    sb.AppendFormat(categorySentence, sizeString, "DVD-ROM", decoded.PartVersion).AppendLine();
                    switch(decoded.DiscSize)
                    {
                        case DVDSize.OneTwenty when decoded.PartVersion == 1:
                            sb.AppendLine("Disc claims conformation to ECMA-267");
                            break;
                        case DVDSize.Eighty when decoded.PartVersion == 1:
                            sb.AppendLine("Disc claims conformation to ECMA-268");
                            break;
                    }

                    break;
                case DiskCategory.DVDRAM:
                    sb.AppendFormat(categorySentence, sizeString, "DVD-RAM", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-272");
                            break;
                        case 6:
                            sb.AppendLine("Disc claims conformation to ECMA-330");
                            break;
                    }

                    break;
                case DiskCategory.DVDR:
                    if(decoded.PartVersion >= 6)
                        sb.AppendFormat(categorySentence, sizeString, "DVD-R DL", decoded.PartVersion).AppendLine();
                    else sb.AppendFormat(categorySentence, sizeString, "DVD-R", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-279");
                            break;
                        case 5:
                            sb.AppendLine("Disc claims conformation to ECMA-359");
                            break;
                        case 6:
                            sb.AppendLine("Disc claims conformation to ECMA-382");
                            break;
                    }

                    break;
                case DiskCategory.DVDRW:
                    if(decoded.PartVersion >= 3)
                        sb.AppendFormat(categorySentence, sizeString, "DVD-RW DL", decoded.PartVersion).AppendLine();
                    else sb.AppendFormat(categorySentence, sizeString, "DVD-RW", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 2:
                            sb.AppendLine("Disc claims conformation to ECMA-338");
                            break;
                        case 3:
                            sb.AppendLine("Disc claims conformation to ECMA-384");
                            break;
                    }

                    break;
                case DiskCategory.UMD:
                    if(decoded.DiscSize == DVDSize.OneTwenty)
                        sb.AppendFormat(categorySentence, "60mm", "UMD", decoded.PartVersion).AppendLine();
                    else sb.AppendFormat(categorySentence, "invalid size", "UMD", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 0:
                            sb.AppendLine("Disc claims conformation to ECMA-365");
                            break;
                    }

                    break;
                case DiskCategory.DVDPRW:
                    sb.AppendFormat(categorySentence, sizeString, "DVD+RW", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-274");
                            break;
                        case 2:
                            sb.AppendLine("Disc claims conformation to ECMA-337");
                            break;
                        case 3:
                            sb.AppendLine("Disc claims conformation to ECMA-371");
                            break;
                    }

                    break;
                case DiskCategory.DVDPR:
                    sb.AppendFormat(categorySentence, sizeString, "DVD+R", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-349");
                            break;
                    }

                    break;
                case DiskCategory.DVDPRWDL:
                    sb.AppendFormat(categorySentence, sizeString, "DVD+RW DL", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-374");
                            break;
                    }

                    break;
                case DiskCategory.DVDPRDL:
                    sb.AppendFormat(categorySentence, sizeString, "DVD+R DL", decoded.PartVersion).AppendLine();
                    switch(decoded.PartVersion)
                    {
                        case 1:
                            sb.AppendLine("Disc claims conformation to ECMA-364");
                            break;
                    }

                    break;
                case DiskCategory.Nintendo:
                    if(decoded.PartVersion == 15)
                        if(decoded.DiscSize == DVDSize.Eighty)
                            sb.AppendLine("Disc is a Nintendo Gamecube Optical Disc (GOD)");
                        else if(decoded.DiscSize == DVDSize.OneTwenty)
                            sb.AppendLine("Disc is a Nintendo Wii Optical Disc (WOD)");
                        else goto default;
                    else goto default;
                    break;
                case DiskCategory.HDDVDROM:
                    sb.AppendFormat(categorySentence, sizeString, "HD DVD-ROM", decoded.PartVersion).AppendLine();
                    break;
                case DiskCategory.HDDVDRAM:
                    sb.AppendFormat(categorySentence, sizeString, "HD DVD-RAM", decoded.PartVersion).AppendLine();
                    break;
                case DiskCategory.HDDVDR:
                    sb.AppendFormat(categorySentence, sizeString, "HD DVD-R", decoded.PartVersion).AppendLine();
                    break;
                case DiskCategory.HDDVDRW:
                    sb.AppendFormat(categorySentence, sizeString, "HD DVD-RW", decoded.PartVersion).AppendLine();
                    break;
                default:
                    sb.AppendFormat(categorySentence, sizeString, "unknown disc type", decoded.PartVersion)
                      .AppendLine();
                    break;
            }

            switch(decoded.MaximumRate)
            {
                case MaximumRateField.TwoMbps:
                    sb.AppendLine("Disc maximum transfer rate is 2,52 Mbit/sec.");
                    break;
                case MaximumRateField.FiveMbps:
                    sb.AppendLine("Disc maximum transfer rate is 5,04 Mbit/sec.");
                    break;
                case MaximumRateField.TenMbps:
                    sb.AppendLine("Disc maximum transfer rate is 10,08 Mbit/sec.");
                    break;
                case MaximumRateField.TwentyMbps:
                    sb.AppendLine("Disc maximum transfer rate is 20,16 Mbit/sec.");
                    break;
                case MaximumRateField.ThirtyMbps:
                    sb.AppendLine("Disc maximum transfer rate is 30,24 Mbit/sec.");
                    break;
                case MaximumRateField.Unspecified:
                    sb.AppendLine("Disc maximum transfer rate is unspecified.");
                    break;
                default:
                    sb.AppendFormat("Disc maximum transfer rate is specified by unknown key {0}", decoded.MaximumRate)
                      .AppendLine();
                    break;
            }

            sb.AppendFormat("Disc has {0} layers", decoded.Layers + 1).AppendLine();
            if(decoded.TrackPath       && decoded.Layers == 1) sb.AppendLine("Layers are in parallel track path");
            else if(!decoded.TrackPath && decoded.Layers == 1) sb.AppendLine("Layers are in opposite track path");

            switch(decoded.LinearDensity)
            {
                case LinearDensityField.TwoSix:
                    sb.AppendLine("Pitch size is 0,267 μm/bit");
                    break;
                case LinearDensityField.TwoNine:
                    sb.AppendLine("Pitch size is 0,147 μm/bit");
                    break;
                case LinearDensityField.FourZero:
                    sb.AppendLine("Pitch size is between 0,409 μm/bit and 0,435 μm/bit");
                    break;
                case LinearDensityField.TwoEight:
                    sb.AppendLine("Pitch size is between 0,140 μm/bit and 0,148 μm/bit");
                    break;
                case LinearDensityField.OneFive:
                    sb.AppendLine("Pitch size is 0,153 μm/bit");
                    break;
                case LinearDensityField.OneThree:
                    sb.AppendLine("Pitch size is between 0,130 μm/bit and 0,140 μm/bit");
                    break;
                case LinearDensityField.ThreeFive:
                    sb.AppendLine("Pitch size is 0,353 μm/bit");
                    break;
                default:
                    sb.AppendFormat("Unknown pitch size key {0}", decoded.LinearDensity).AppendLine();
                    break;
            }

            switch(decoded.TrackDensity)
            {
                case TrackDensityField.Seven:
                    sb.AppendLine("Track size is 0,74 μm");
                    break;
                case TrackDensityField.Eight:
                    sb.AppendLine("Track size is 0,80 μm");
                    break;
                case TrackDensityField.Six:
                    sb.AppendLine("Track size is 0,615 μm");
                    break;
                case TrackDensityField.Four:
                    sb.AppendLine("Track size is 0,40 μm");
                    break;
                case TrackDensityField.Three:
                    sb.AppendLine("Track size is 0,34 μm");
                    break;
                default:
                    sb.AppendFormat("Unknown track size key {0}", decoded.LinearDensity).AppendLine();
                    break;
            }

            if(decoded.DataAreaStartPSN > 0)
                if(decoded.DataAreaEndPSN > 0)
                {
                    sb.AppendFormat("Data area starts at PSN {0:X}h", decoded.DataAreaStartPSN).AppendLine();
                    sb.AppendFormat("Data area ends at PSN {0:X}h", decoded.DataAreaEndPSN).AppendLine();
                    if(decoded.Layers == 1 && !decoded.TrackPath)
                        sb.AppendFormat("Layer 0 ends at PSN {0:X}h", decoded.Layer0EndPSN).AppendLine();
                }
                else
                    sb.AppendLine("Disc is empty");
            else sb.AppendLine("Disc is empty");

            if(decoded.BCA) sb.AppendLine("Disc has a burst cutting area");

            switch(decoded.DiskCategory)
            {
                case DiskCategory.UMD:
                    sb.AppendFormat("Media attribute is {0}", decoded.MediaAttribute).AppendLine();
                    break;
                case DiskCategory.DVDRAM:
                    switch(decoded.DiscType)
                    {
                        case DVDRAMDiscType.Cased:
                            sb.AppendLine("Disc shall be recorded with a case");
                            break;
                        case DVDRAMDiscType.Uncased:
                            sb.AppendLine("Disc can be recorded with or without a case");
                            break;
                        default:
                            sb.AppendFormat("Unknown DVD-RAM case type key {0}", decoded.DiscType).AppendLine();
                            break;
                    }

                    if(decoded.PartVersion == 6)
                    {
                        sb.AppendFormat("Disc manufacturer is {0}", decoded.DiskManufacturer).AppendLine();
                        sb.AppendFormat("Disc manufacturer supplementary information is {0}",
                                        decoded.DiskManufacturerSupplementary).AppendLine();
                    }

                    break;
                case DiskCategory.DVDR when decoded.PartVersion  < 6:
                case DiskCategory.DVDRW when decoded.PartVersion < 3:
                    sb.AppendFormat("Current Border-Out first sector is PSN {0:X}h", decoded.CurrentBorderOutSector)
                      .AppendLine();
                    sb.AppendFormat("Next Border-In first sector is PSN {0:X}h", decoded.NextBorderInSector)
                      .AppendLine();
                    break;
                case DiskCategory.DVDPR:
                case DiskCategory.DVDPRW:
                case DiskCategory.DVDPRDL:
                case DiskCategory.DVDPRWDL:
                    if(decoded.VCPS) sb.AppendLine("Disc contains extended information for VCPS");
                    sb.AppendFormat("Disc application code is {0}", decoded.ApplicationCode).AppendLine();
                    sb.AppendFormat("Disc manufacturer is {0}", decoded.DiskManufacturerID).AppendLine();
                    sb.AppendFormat("Disc media type is {0}", decoded.MediaTypeID).AppendLine();
                    sb.AppendFormat("Disc product revision is {0}", decoded.ProductRevision).AppendLine();
                    break;
            }

            if((decoded.DiskCategory != DiskCategory.DVDR  || decoded.PartVersion < 6) &&
               (decoded.DiskCategory != DiskCategory.DVDRW || decoded.PartVersion < 3)) return sb.ToString();

            sb.AppendFormat("Current RMD in extra Border zone starts at PSN {0:X}h", decoded.CurrentRMDExtraBorderPSN)
              .AppendLine();
            sb.AppendFormat("PFI in extra Border zone starts at PSN {0:X}h", decoded.PFIExtraBorderPSN).AppendLine();
            if(!decoded.PreRecordedControlDataInv) sb.AppendLine("Control Data Zone is pre-recorded");
            if(decoded.PreRecordedLeadIn) sb.AppendLine("Lead-In is pre-recorded");
            if(decoded.PreRecordedLeadOut) sb.AppendLine("Lead-Out is pre-recorded");

            return sb.ToString();
        }

        public static string Prettify(byte[] response)
        {
            return Prettify(Decode(response));
        }
    }
}