#include "tiffimage_int.hpp"

#include "error.hpp"

#include "makernote_int.hpp"

#include "sonymn_int.hpp"

#include "tiffvisitor_int.hpp"

#include "i18n.h"                // NLS support.

// Shortcuts for the newTiffBinaryArray templates.

#define EXV_BINARY_ARRAY(arrayCfg, arrayDef) (newTiffBinaryArray0<&arrayCfg, EXV_COUNTOF(arrayDef), arrayDef>)

#define EXV_SIMPLE_BINARY_ARRAY(arrayCfg) (newTiffBinaryArray1<&arrayCfg>)

#define EXV_COMPLEX_BINARY_ARRAY(arraySet, cfgSelFct) (newTiffBinaryArray2<arraySet, EXV_COUNTOF(arraySet), cfgSelFct>)

namespace Exiv2 {

    namespace Internal {

    //! Constant for non-encrypted binary arrays

    const CryptFct notEncrypted = 0;

    //! Canon Camera Settings binary array - configuration

    extern const ArrayCfg canonCsCfg = {

        canonCsId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // With size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Canon Camera Settings binary array - definition

    extern const ArrayDef canonCsDef[] = {

        { 46, ttUnsignedShort, 3 } // Exif.CanonCs.Lens

    };

    //! Canon Shot Info binary array - configuration

    extern const ArrayCfg canonSiCfg = {

        canonSiId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // With size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Canon Panorama binary array - configuration

    extern const ArrayCfg canonPaCfg = {

        canonPaId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Canon Custom Function binary array - configuration

    extern const ArrayCfg canonCfCfg = {

        canonCfId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // With size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Canon Picture Info binary array - configuration

    extern const ArrayCfg canonPiCfg = {

        canonPiId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Canon Time Info binary array - configuration

    extern const ArrayCfg canonTiCfg = {

        canonTiId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttSignedLong,     // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // With size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttSignedLong, 1 }

    };

    //! Canon File Info binary array - configuration

    extern const ArrayCfg canonFiCfg = {

        canonFiId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // Has a size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttSignedShort, 1 }

    };

    //! Canon File Info binary array - definition

    extern const ArrayDef canonFiDef[] = {

        { 2, ttUnsignedLong, 1 }

    };

    //! Canon Processing Info binary array - configuration

    extern const ArrayCfg canonPrCfg = {

        canonPrId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUnsignedShort,  // Type for array entry and size element

        notEncrypted,     // Not encrypted

        true,             // Has a size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttSignedShort, 1 }

    };

    //! Nikon Vibration Reduction binary array - configuration

    extern const ArrayCfg nikonVrCfg = {

        nikonVrId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Vibration Reduction binary array - definition

    extern const ArrayDef nikonVrDef[] = {

        { 0, ttUndefined,     4 }, // Version

        { 7, ttUnsignedByte,  1 }  // The array contains 8 bytes

    };

    //! Nikon Picture Control binary array - configuration

    extern const ArrayCfg nikonPcCfg = {

        nikonPcId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Picture Control binary array - definition

    extern const ArrayDef nikonPcDef[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttAsciiString,  20 },

        { 24, ttAsciiString,  20 },

        { 48, ttUnsignedByte,  1 },

        { 49, ttUnsignedByte,  1 },

        { 50, ttUnsignedByte,  1 },

        { 51, ttUnsignedByte,  1 },

        { 52, ttUnsignedByte,  1 },

        { 53, ttUnsignedByte,  1 },

        { 54, ttUnsignedByte,  1 },

        { 55, ttUnsignedByte,  1 },

        { 56, ttUnsignedByte,  1 },

        { 57, ttUnsignedByte,  1 }  // The array contains 58 bytes

    };

    //! Nikon World Time binary array - configuration

    extern const ArrayCfg nikonWtCfg = {

        nikonWtId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon World Time binary array - definition

    extern const ArrayDef nikonWtDef[] = {

        { 0, ttSignedShort,   1 },

        { 2, ttUnsignedByte,  1 },

        { 3, ttUnsignedByte,  1 }

    };

    //! Nikon ISO info binary array - configuration

    extern const ArrayCfg nikonIiCfg = {

        nikonIiId,        // Group for the elements

        bigEndian,        // Byte order

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon ISO info binary array - definition

    extern const ArrayDef nikonIiDef[] = {

        {  0, ttUnsignedByte,  1 },

        {  4, ttUnsignedShort, 1 },

        {  6, ttUnsignedByte,  1 },

        { 10, ttUnsignedShort, 1 },

        { 13, ttUnsignedByte,  1 }  // The array contains 14 bytes

    };

    //! Nikon Auto Focus binary array - configuration

    extern const ArrayCfg nikonAfCfg = {

        nikonAfId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Auto Focus binary array - definition

    extern const ArrayDef nikonAfDef[] = {

        { 0, ttUnsignedByte,  1 },

        { 1, ttUnsignedByte,  1 },

        { 2, ttUnsignedShort, 1 } // The array contains 4 bytes

    };

    //! Nikon Auto Focus 21 binary array - configuration

    extern const ArrayCfg nikonAf21Cfg = {

        nikonAf21Id,      // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Auto Focus 21 binary array - definition

    extern const ArrayDef nikonAf21Def[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedByte,  1 }, // ContrastDetectAF

        {  5, ttUnsignedByte,  1 }, // AFAreaMode

        {  6, ttUnsignedByte,  1 }, // PhaseDetectAF

        {  7, ttUnsignedByte,  1 }, // PrimaryAFPoint

        {  8, ttUnsignedByte,  7 }, // AFPointsUsed

        { 16, ttUnsignedShort, 1 }, // AFImageWidth

        { 18, ttUnsignedShort, 1 }, // AFImageHeight

        { 20, ttUnsignedShort, 1 }, // AFAreaXPosition

        { 22, ttUnsignedShort, 1 }, // AFAreaYPosition

        { 24, ttUnsignedShort, 1 }, // AFAreaWidth

        { 26, ttUnsignedShort, 1 }, // AFAreaHeight

        { 28, ttUnsignedShort, 1 }, // ContrastDetectAFInFocus

    };

    //! Nikon Auto Focus 22 binary array - configuration

    extern const ArrayCfg nikonAf22Cfg = {

        nikonAf22Id,      // Group for the elements

        invalidByteOrder, // Byte order

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,            // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Auto Focus 22 binary array - definition

    extern const ArrayDef nikonAf22Def[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedByte,  1 }, // ContrastDetectAF

        {  5, ttUnsignedByte,  1 }, // AFAreaMode

        {  6, ttUnsignedByte,  1 }, // PhaseDetectAF

        {  7, ttUnsignedByte,  1 }, // PrimaryAFPoint

        {  8, ttUnsignedByte,  7 }, // AFPointsUsed

        { 70, ttUnsignedShort, 1 }, // AFImageWidth

        { 72, ttUnsignedShort, 1 }, // AFImageHeight

        { 74, ttUnsignedShort, 1 }, // AFAreaXPosition

        { 76, ttUnsignedShort, 1 }, // AFAreaYPosition

        { 78, ttUnsignedShort, 1 }, // AFAreaWidth

        { 80, ttUnsignedShort, 1 }, // AFAreaHeight

    };

    //! Nikon AF2 configuration and definitions

    //  https://github.com/Exiv2/exiv2/issues/646

    extern const ArraySet nikonAf2Set[] = {

        { nikonAf21Cfg, nikonAf21Def, EXV_COUNTOF(nikonAf21Def) },

        { nikonAf22Cfg, nikonAf22Def, EXV_COUNTOF(nikonAf22Def) },

    };

    //! Nikon AF Fine Tune binary array - configuration

    extern const ArrayCfg nikonAFTCfg = {

        nikonAFTId,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon AF Fine Tune binary array - definition

    extern const ArrayDef nikonAFTDef[] = {

        {  0, ttUnsignedByte,  1 }, // AF Fine Tune on/off

        {  1, ttUnsignedByte,  1 }, // AF Fine Tune index

        {  2, ttUnsignedByte,  1 }  // AF Fine Tune value

    };

    //! Nikon File Info binary array - configuration

    extern const ArrayCfg nikonFiCfg = {

        nikonFiId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon File Info binary array - definition

    extern const ArrayDef nikonFiDef[] = {

        { 0, ttUndefined,     4 }, // Version

        { 6, ttUnsignedShort, 1 }, // Directory Number

        { 8, ttUnsignedShort, 1 }  // File Number

    };

    //! Nikon Multi Exposure binary array - configuration

    extern const ArrayCfg nikonMeCfg = {

        nikonMeId,        // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Multi Exposure binary array - definition

    extern const ArrayDef nikonMeDef[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedLong,  1 }, // MultiExposureMode

        {  8, ttUnsignedLong,  1 }, // MultiExposureShots

        { 12, ttUnsignedLong,  1 }  // MultiExposureAutoGain

    };

    //! Nikon Flash Info binary array - configuration 1

    extern const ArrayCfg nikonFl1Cfg = {

        nikonFl1Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Flash Info binary array - definition 1

    extern const ArrayDef nikonFl1Def[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedByte,  1 }, // FlashSource

        {  6, ttUnsignedShort, 1 }, // ExternalFlashFirmware

        {  8, ttUnsignedByte,  1 }, // ExternalFlashFlags

        { 11, ttUnsignedByte,  1 }, // FlashFocalLength

        { 12, ttUnsignedByte,  1 }, // RepeatingFlashRate

        { 13, ttUnsignedByte,  1 }, // RepeatingFlashCount

        { 14, ttUnsignedByte,  1 }, // FlashGNDistance

        { 15, ttUnsignedByte,  1 }, // FlashGroupAControlMode

        { 16, ttUnsignedByte,  1 }  // FlashGroupBControlMode

    };

    //! Nikon Flash Info binary array - configuration 2

    extern const ArrayCfg nikonFl2Cfg = {

        nikonFl2Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Flash Info binary array - definition 2

    extern const ArrayDef nikonFl2Def[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedByte,  1 }, // FlashSource

        {  6, ttUnsignedShort, 1 }, // ExternalFlashFirmware

        {  8, ttUnsignedByte,  1 }, // ExternalFlashFlags

        { 12, ttUnsignedByte,  1 }, // FlashFocalLength

        { 13, ttUnsignedByte,  1 }, // RepeatingFlashRate

        { 14, ttUnsignedByte,  1 }, // RepeatingFlashCount

        { 15, ttUnsignedByte,  1 }, // FlashGNDistance

    };

    //! Nikon Flash Info binary array - configuration 3

    extern const ArrayCfg nikonFl3Cfg = {

        nikonFl3Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Not encrypted

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Flash Info binary array - definition

    extern const ArrayDef nikonFl3Def[] = {

        {  0, ttUndefined,     4 }, // Version

        {  4, ttUnsignedByte,  1 }, // FlashSource

        {  6, ttUnsignedShort, 1 }, // ExternalFlashFirmware

        {  8, ttUnsignedByte,  1 }, // ExternalFlashFlags

        { 12, ttUnsignedByte,  1 }, // FlashFocalLength

        { 13, ttUnsignedByte,  1 }, // RepeatingFlashRate

        { 14, ttUnsignedByte,  1 }, // RepeatingFlashCount

        { 15, ttUnsignedByte,  1 }, // FlashGNDistance

        { 16, ttUnsignedByte,  1 }, // FlashColorFilter

    };

    //! Nikon Lens Data configurations and definitions

    extern const ArraySet nikonFlSet[] = {

        { nikonFl1Cfg, nikonFl1Def, EXV_COUNTOF(nikonFl1Def) },

        { nikonFl2Cfg, nikonFl2Def, EXV_COUNTOF(nikonFl2Def) },

        { nikonFl3Cfg, nikonFl3Def, EXV_COUNTOF(nikonFl3Def) }

    };

    //! Nikon Shot Info binary array - configuration 1 (D80)

    extern const ArrayCfg nikonSi1Cfg = {

        nikonSi1Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Shot Info binary array - definition 1 (D80)

    extern const ArrayDef nikonSi1Def[] = {

        {    0, ttUndefined,    4 }, // Version

        {  586, ttUnsignedLong, 1 }, // ShutterCount

        { 1155, ttUnsignedByte, 1 }  // The array contains 1156 bytes

    };

    //! Nikon Shot Info binary array - configuration 2 (D40)

    extern const ArrayCfg nikonSi2Cfg = {

        nikonSi2Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Shot Info binary array - definition 2 (D40)

    extern const ArrayDef nikonSi2Def[] = {

        {    0, ttUndefined,    4 }, // Version

        {  582, ttUnsignedLong, 1 }, // ShutterCount

        {  738, ttUnsignedByte, 1 },

        { 1112, ttUnsignedByte, 1 }  // The array contains 1113 bytes

    };

    //! Nikon Shot Info binary array - configuration 3 (D300a)

    extern const ArrayCfg nikonSi3Cfg = {

        nikonSi3Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Shot Info binary array - definition 3 (D300a)

    extern const ArrayDef nikonSi3Def[] = {

        {    0, ttUndefined,     4 }, // Version

        {  604, ttUnsignedByte,  1 }, // ISO

        {  633, ttUnsignedLong,  1 }, // ShutterCount

        {  721, ttUnsignedShort, 1 }, // AFFineTuneAdj

        {  814, ttUndefined,  4478 }  // The array contains 5291 bytes

    };

    //! Nikon Shot Info binary array - configuration 4 (D300b)

    extern const ArrayCfg nikonSi4Cfg = {

        nikonSi4Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Shot Info binary array - definition 4 (D300b)

    extern const ArrayDef nikonSi4Def[] = {

        {    0, ttUndefined,     4 }, // Version

        {  644, ttUnsignedLong,  1 }, // ShutterCount

        {  732, ttUnsignedShort, 1 }, // AFFineTuneAdj

        {  826, ttUndefined,  4478 }  // The array contains 5303 bytes

    };

    //! Nikon Shot Info binary array - configuration 5 (ver 02.xx)

    extern const ArrayCfg nikonSi5Cfg = {

        nikonSi5Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        false,            // Write all tags (don't know how many)

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Shot Info binary array - definition 5 (ver 01.xx and ver 02.xx)

    extern const ArrayDef nikonSi5Def[] = {

        {    0, ttUndefined,     4 }, // Version

        {  106, ttUnsignedLong,  1 }, // ShutterCount1

        {  110, ttUnsignedLong,  1 }, // DeletedImageCount

        {  117, ttUnsignedByte,  1 }, // VibrationReduction

        {  130, ttUnsignedByte,  1 }, // VibrationReduction1

        {  343, ttUndefined,     2 }, // ShutterCount

        {  430, ttUnsignedByte,  1 }, // VibrationReduction2

        {  598, ttUnsignedByte,  1 }, // ISO

        {  630, ttUnsignedLong,  1 }  // ShutterCount

    };

    //! Nikon Shot Info binary array - configuration 6 (ver 01.xx)

    extern const ArrayCfg nikonSi6Cfg = {

        nikonSi6Id,       // Group for the elements

        bigEndian,        // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Encryption function

        false,            // No size element

        false,            // Write all tags (don't know how many)

        true,             // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Lens Data configurations and definitions

    extern const ArraySet nikonSiSet[] = {

        { nikonSi1Cfg, nikonSi1Def, EXV_COUNTOF(nikonSi1Def) },

        { nikonSi2Cfg, nikonSi2Def, EXV_COUNTOF(nikonSi2Def) },

        { nikonSi3Cfg, nikonSi3Def, EXV_COUNTOF(nikonSi3Def) },

        { nikonSi4Cfg, nikonSi4Def, EXV_COUNTOF(nikonSi4Def) },

        { nikonSi5Cfg, nikonSi5Def, EXV_COUNTOF(nikonSi5Def) },

        { nikonSi6Cfg, nikonSi5Def, EXV_COUNTOF(nikonSi5Def) }  // uses nikonSi5Def

    };

    //! Nikon Lens Data binary array - configuration 1

    extern const ArrayCfg nikonLd1Cfg = {

        nikonLd1Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Encryption function

        false,            // No size element

        true,             // Write all tags

        false,            // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Lens Data binary array - configuration 2

    extern const ArrayCfg nikonLd2Cfg = {

        nikonLd2Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        false,            // Concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Lens Data binary array - configuration 3

    extern const ArrayCfg nikonLd3Cfg = {

        nikonLd3Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        true,             // Write all tags

        false,            // Don't concatenate gaps

        { 0, ttUnsignedByte,  1 }

    };

    //! Nikon Lens Data binary array - definition

    extern const ArrayDef nikonLdDef[] = {

        { 0, ttUndefined, 4 } // Version

    };

    //! Nikon Lens Data configurations and definitions

    extern const ArraySet nikonLdSet[] = {

        { nikonLd1Cfg, nikonLdDef, EXV_COUNTOF(nikonLdDef) },

        { nikonLd2Cfg, nikonLdDef, EXV_COUNTOF(nikonLdDef) },

        { nikonLd3Cfg, nikonLdDef, EXV_COUNTOF(nikonLdDef) }

    };

    //! Nikon Color Balance binary array - configuration 1

    extern const ArrayCfg nikonCb1Cfg = {

        nikonCb1Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - configuration 2

    extern const ArrayCfg nikonCb2Cfg = {

        nikonCb2Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - configuration 2a

    extern const ArrayCfg nikonCb2aCfg = {

        nikonCb2aId,      // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - configuration 2b

    extern const ArrayCfg nikonCb2bCfg = {

        nikonCb2bId,      // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - configuration 3

    extern const ArrayCfg nikonCb3Cfg = {

        nikonCb3Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        notEncrypted,     // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - configuration 4

    extern const ArrayCfg nikonCb4Cfg = {

        nikonCb4Id,       // Group for the elements

        invalidByteOrder, // Use byte order from parent

        ttUndefined,      // Type for array entry

        nikonCrypt,       // Encryption function

        false,            // No size element

        false,            // Write all tags

        true,             // Concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Nikon Color Balance binary array - definition 1 (D100)

    extern const ArrayDef nikonCb1Def[] = {

        {  0, ttUndefined,        4 }, // Version

        { 72, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance binary array - definition 2 (D2H)

    extern const ArrayDef nikonCb2Def[] = {

        {  0, ttUndefined,        4 }, // Version

        { 10, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance binary array - definition 2a (D50)

    extern const ArrayDef nikonCb2aDef[] = {

        {  0, ttUndefined,        4 }, // Version

        { 18, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance binary array - definition 2b (D2X=0204,D2Hs=0206,D200=0207,D40=0208)

    extern const ArrayDef nikonCb2bDef[] = {

        {  0, ttUndefined,        4 }, // Version

        {  4, ttUnsignedShort,  140 }, // Unknown

        {284, ttUnsignedShort,    3 }, // Unknown (encrypted)

        {290, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance binary array - definition 3 (D70)

    extern const ArrayDef nikonCb3Def[] = {

        {  0, ttUndefined,        4 }, // Version

        { 20, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance binary array - definition 4 (D3)

    extern const ArrayDef nikonCb4Def[] = {

        {  0, ttUndefined,        4 }, // Version

        {  4, ttUnsignedShort,  140 }, // Unknown

        {284, ttUnsignedShort,    5 }, // Unknown (encrypted)

        {294, ttUnsignedShort,    4 }  // Color balance levels

    };

    //! Nikon Color Balance configurations and definitions

    extern const ArraySet nikonCbSet[] = {

        { nikonCb1Cfg,  nikonCb1Def,  EXV_COUNTOF(nikonCb1Def)  },

        { nikonCb2Cfg,  nikonCb2Def,  EXV_COUNTOF(nikonCb2Def)  },

        { nikonCb2aCfg, nikonCb2aDef, EXV_COUNTOF(nikonCb2aDef) },

        { nikonCb2bCfg, nikonCb2bDef, EXV_COUNTOF(nikonCb2bDef) },

        { nikonCb3Cfg,  nikonCb3Def,  EXV_COUNTOF(nikonCb3Def)  },

        { nikonCb4Cfg,  nikonCb4Def,  EXV_COUNTOF(nikonCb4Def)  }

    };

    //! Minolta Camera Settings (old) binary array - configuration

    extern const ArrayCfg minoCsoCfg = {

        minoltaCsOldId,   // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedLong, 1 }

    };

    //! Minolta Camera Settings (new) binary array - configuration

    extern const ArrayCfg minoCsnCfg = {

        minoltaCsNewId,   // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedLong, 1 }

    };

    //! Minolta 7D Camera Settings binary array - configuration

    extern const ArrayCfg minoCs7Cfg = {

        minoltaCs7DId,    // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Minolta 7D Camera Settings binary array - definition

    extern const ArrayDef minoCs7Def[] = {

        {  60, ttSignedShort, 1 }, // Exif.MinoltaCs7D.ExposureCompensation

        { 126, ttSignedShort, 1 }  // Exif.MinoltaCs7D.ColorTemperature

    };

    //! Minolta 5D Camera Settings binary array - configuration

    extern const ArrayCfg minoCs5Cfg = {

        minoltaCs5DId,    // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Minolta 5D Camera Settings binary array - definition

    extern const ArrayDef minoCs5Def[] = {

        { 146, ttSignedShort, 1 } // Exif.MinoltaCs5D.ColorTemperature

    };

    // Todo: Performance of the handling of Sony Camera Settings can be

    //       improved by defining all known array elements in the definitions

    //       sonyCsDef and sonyCs2Def below and enabling the 'concatenate gaps'

    //       setting in all four configurations.

    //! Sony1 Camera Settings binary array - configuration

    extern const ArrayCfg sony1CsCfg = {

        sony1CsId,        // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Sony1 Camera Settings 2 binary array - configuration

    extern const ArrayCfg sony1Cs2Cfg = {

        sony1Cs2Id,       // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    extern const ArrayCfg sony2FpCfg = {

        sony2FpId,        // Group for the elements

        bigEndian,        // Big endian

        ttUnsignedByte,   // Type for array entry and size element

        sonyTagDecipher,  // (uint16_t, const byte*, uint32_t, TiffComponent* const);

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedByte, 1 }

    };

    extern const ArrayDef sony2FpDef[] = {

        {  0x4, ttSignedByte  , 1 }, // Exif.Sony2Fp.AmbientTemperature

        { 0x16, ttUnsignedByte, 1 }, // Exif.Sony2Fp.FocusMode

        { 0x17, ttUnsignedByte, 1 }, // Exif.Sony2Fp.AFAreaMode

        { 0x2d, ttUnsignedByte, 1 }  // Exif.Sony2Fp.FocusPosition2

    };

    //! Sony[12] Camera Settings binary array - definition

    extern const ArrayDef sonyCsDef[] = {

        {  12, ttSignedShort,   1 }  // Exif.Sony[12]Cs.WhiteBalanceFineTune

    };

    //! Sony2 Camera Settings binary array - configuration

    extern const ArrayCfg sony2CsCfg = {

        sony2CsId,        // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Sony2 Camera Settings 2 binary array - configuration

    extern const ArrayCfg sony2Cs2Cfg = {

        sony2Cs2Id,       // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Sony[12] Camera Settings 2 binary array - definition

    extern const ArrayDef sonyCs2Def[] = {

        {  44, ttUnsignedShort, 1 } // Exif.Sony[12]Cs2.FocusMode

    };

    //! Sony1 Camera Settings configurations and definitions

    extern const ArraySet sony1CsSet[] = {

        { sony1CsCfg,  sonyCsDef,  EXV_COUNTOF(sonyCsDef)  },

        { sony1Cs2Cfg, sonyCs2Def, EXV_COUNTOF(sonyCs2Def) }

    };

    //! Sony2 Camera Settings configurations and definitions

    extern const ArraySet sony2CsSet[] = {

        { sony2CsCfg,  sonyCsDef,  EXV_COUNTOF(sonyCsDef)  },

        { sony2Cs2Cfg, sonyCs2Def, EXV_COUNTOF(sonyCs2Def) }

    };

    //! Sony Minolta Camera Settings (old) binary array - configuration

    extern const ArrayCfg sony1MCsoCfg = {

        sony1MltCsOldId,  // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedLong, 1 }

    };

    //! Sony Minolta Camera Settings (new) binary array - configuration

    extern const ArrayCfg sony1MCsnCfg = {

        sony1MltCsNewId,  // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedLong, 1 }

    };

    //! Sony Minolta 7D Camera Settings binary array - configuration

    extern const ArrayCfg sony1MCs7Cfg = {

        sony1MltCs7DId,   // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Sony Minolta A100 Camera Settings binary array - configuration

    extern const ArrayCfg sony1MCsA100Cfg = {

        sony1MltCsA100Id, // Group for the elements

        bigEndian,        // Big endian

        ttUndefined,      // Type for array entry and size element

        notEncrypted,     // Not encrypted

        false,            // No size element

        false,            // No fillers

        false,            // Don't concatenate gaps

        { 0, ttUnsignedShort, 1 }

    };

    //! Sony Minolta A100 Camera Settings binary array - definition

    extern const ArrayDef sony1MCsA100Def[] = {

        { 112, ttSignedShort, 1 }, // Exif.Sony1MltCsA100.WhiteBalanceFineTune

        { 116, ttSignedShort, 1 }, // Exif.Sony1MltCsA100.ColorCompensationFilter