diff --git a/src/makernote.cpp b/src/makernote.cpp index 4a09be8e..cc39c3b0 100644 --- a/src/makernote.cpp +++ b/src/makernote.cpp @@ -837,13 +837,19 @@ namespace Exiv2 { { 0x0097, "0207", 0, 3, 284 }, { 0x0097, "0208", 0, 3, 284 }, { 0x0097, "0209", 0, 5, 284 }, + { 0x0097, "02", 0, 3, 284 }, // NikonLd { 0x0098, "0100", 0, 0, NA }, { 0x0098, "0101", 0, 1, NA }, { 0x0098, "0201", 0, 1, 4 }, { 0x0098, "0202", 0, 1, 4 }, { 0x0098, "0203", 0, 1, 4 }, - { 0x0098, "0204", 0, 2, 4 } + { 0x0098, "0204", 0, 2, 4 }, + // NikonFl + { 0x00a8, "0100", 0, 0, 4 }, + { 0x00a8, "0101", 0, 0, 4 }, + { 0x00a8, "0102", 0, 1, 4 }, + { 0x00a8, "0103", 0, 2, 4 }, }; int nikonSelector(uint16_t tag, const byte* pData, uint32_t size, TiffComponent* const /*pRoot*/) diff --git a/src/makernote_int.hpp b/src/makernote_int.hpp index 6e1e6621..9824681c 100644 --- a/src/makernote_int.hpp +++ b/src/makernote_int.hpp @@ -141,6 +141,12 @@ namespace Exiv2 { const uint16_t sonysr2dt19=359; //!< Sony SR2 data-IFD 19 tags const uint16_t sonyidc = 360; //!< Sony IDC tags const uint16_t sonyidc2 = 361; //!< Sony IDC 2 tags + const uint16_t nikonfi = 362; //!< Nikon File Info Tags + const uint16_t nikonaf2 = 363; //!< Nikon Auto Focus 2 Tags + const uint16_t nikonme = 364; //!< Nikon Multi Exposure Tags + const uint16_t nikonfl1 = 365; //!< Nikon Flash Info 1 Tags + const uint16_t nikonfl2 = 366; //!< Nikon Flash Info 2 Tags + const uint16_t nikonfl3 = 367; //!< Nikon Flash Info 3 Tags } // ***************************************************************************** diff --git a/src/nikonmn.cpp b/src/nikonmn.cpp index 219f145c..6c676f9a 100644 --- a/src/nikonmn.cpp +++ b/src/nikonmn.cpp @@ -529,11 +529,12 @@ namespace Exiv2 { TagInfo(0x0012, "FlashComp", N_("Flash Comp"), N_("Flash compensation setting"), nikon3IfdId, makerTags, undefined, EXV_PRINT_TAG(nikonFlashComp)), TagInfo(0x0013, "ISOSettings", N_("ISO Settings"), N_("ISO setting"), nikon3IfdId, makerTags, unsignedShort, print0x0002), // use 0x0002 print fct TagInfo(0x0016, "ImageBoundary", N_("Image Boundary"), N_("Image boundary"), nikon3IfdId, makerTags, unsignedShort, printValue), - TagInfo(0x0017, "0x0017", "0x0017", N_("Unknown"), nikon3IfdId, makerTags, undefined, printValue), + TagInfo(0x0017, "FlashExposureComp", "Flash Exposure Comp", N_("Flash exposure comp"), nikon3IfdId, makerTags, undefined, printValue), TagInfo(0x0018, "FlashBracketComp", N_("Flash Bracket Comp"), N_("Flash bracket compensation applied"), nikon3IfdId, makerTags, undefined, EXV_PRINT_TAG(nikonFlashComp)), // use 0x0012 print fct TagInfo(0x0019, "ExposureBracketComp", N_("Exposure Bracket Comp"), N_("AE bracket compensation applied"), nikon3IfdId, makerTags, signedRational, printValue), TagInfo(0x001a, "ImageProcessing", N_("Image Processing"), N_("Image processing"), nikon3IfdId, makerTags, asciiString, printValue), TagInfo(0x001b, "CropHiSpeed", N_("Crop High Speed"), N_("Crop high speed"), nikon3IfdId, makerTags, unsignedShort, printValue), + TagInfo(0x001c, "ExposureTuning", N_("Exposure Tuning"), N_("Exposure tuning"), nikon3IfdId, makerTags, unsignedShort, printValue), TagInfo(0x001d, "SerialNumber", N_("Serial Number"), N_("Serial Number"), nikon3IfdId, makerTags, asciiString, printValue), TagInfo(0x001e, "ColorSpace", N_("Color Space"), N_("Color space"), nikon3IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikonColorSpace)), TagInfo(0x001f, "VRInfo", N_("VR Info"), N_("VR info"), nikon3IfdId, makerTags, undefined, printValue), @@ -796,6 +797,216 @@ namespace Exiv2 { return tagInfoAf_; } + //! PhaseDetectAF + extern const TagDetails nikonPhaseDetectAF[] = { + { 0, N_("Off") }, + { 1, N_("On (51-point)") }, + { 2, N_("On (11-point)") } + }; + + // Nikon3 Auto Focus Tag Info + const TagInfo Nikon3MakerNote::tagInfoAf2_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonAf2IfdId, makerTags, undefined, printExifVersion), + TagInfo( 4, "ContrastDetectAF", N_("Contrast Detect AF"), N_("Contrast detect AF"), nikonAf2IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonOffOn)), + TagInfo( 5, "AFAreaMode", N_("AF Area Mode"), N_("AF area mode"), nikonAf2IfdId, makerTags, unsignedByte, printValue), + TagInfo( 6, "PhaseDetectAF", N_("Phase Detect AF"), N_("Phase detect AF"), nikonAf2IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonPhaseDetectAF)), + TagInfo( 7, "PrimaryAFPoint", N_("Primary AF Point"), N_("Primary AF point"), nikonAf2IfdId, makerTags, unsignedByte, printValue), + TagInfo( 8, "AFPointsUsed", N_("AF Points Used"), N_("AF points used"), nikonAf2IfdId, makerTags, unsignedByte, printValue), + TagInfo( 16, "AFImageWidth", N_("AF Image Width"), N_("AF image width"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 18, "AFImageHeight", N_("AF Image Height"), N_("AF image height"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 20, "AFAreaXPosition", N_("AF Area X Position"), N_("AF area x position"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 22, "AFAreaYPosition", N_("AF Area Y Position"), N_("AF area y position"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 24, "AFAreaWidth", N_("AF Area Width"), N_("AF area width"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 26, "AFAreaHeight", N_("AF Area Height"), N_("AF area height"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + TagInfo( 28, "ContrastDetectAFInFocus", N_("Contrast Detect AF In Focus"), N_("Contrast detect AF in focus"), nikonAf2IfdId, makerTags, unsignedShort, printValue), + // End of list marker + TagInfo(0xffff, "(UnknownNikonAf2Tag)", "(UnknownNikonAf2Tag)", N_("Unknown Nikon Auto Focus 2 Tag"), nikonAf2IfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListAf2() + { + return tagInfoAf2_; + } + + // Nikon3 File Info Tag Info + const TagInfo Nikon3MakerNote::tagInfoFi_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonFiIfdId, makerTags, undefined, printExifVersion), + TagInfo( 6, "DirectoryNumber", N_("Directory Number"), N_("Directory number"), nikonFiIfdId, makerTags, unsignedShort, printValue), + TagInfo( 8, "FileNumber", N_("File Number"), N_("File number"), nikonFiIfdId, makerTags, unsignedShort, printValue), + // End of list marker + TagInfo(0xffff, "(UnknownNikonFiTag)", "(UnknownNikonFiTag)", N_("Unknown Nikon File Info Tag"), nikonFiIfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListFi() + { + return tagInfoFi_; + } + + //! MultiExposureMode + extern const TagDetails nikonMultiExposureMode[] = { + { 0, N_("Off") }, + { 1, N_("Multiple Exposure") }, + { 2, N_("Image Overlay") } + }; + + // Nikon3 Multi Exposure Tag Info + const TagInfo Nikon3MakerNote::tagInfoMe_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonMeIfdId, makerTags, undefined, printExifVersion), + TagInfo( 4, "MultiExposureMode", N_("Multi Exposure Mode"), N_("Multi exposure mode"), nikonMeIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(nikonMultiExposureMode)), + TagInfo( 8, "MultiExposureShots", N_("Multi Exposure Shots"), N_("Multi exposure shots"), nikonMeIfdId, makerTags, unsignedLong, printValue), + TagInfo( 12, "MultiExposureAutoGain", N_("Multi Exposure Auto Gain"), N_("Multi exposure auto gain"), nikonMeIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(nikonOffOn)), + // End of list marker + TagInfo(0xffff, "(UnknownNikonMeTag)", "(UnknownNikonMeTag)", N_("Unknown Nikon Multi Exposure Tag"), nikonMeIfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListMe() + { + return tagInfoMe_; + } + + //! FlashSource + extern const TagDetails nikonFlashSource[] = { + { 0, N_("None") }, + { 1, N_("External") }, + { 2, N_("Internal") } + }; + + //! FlashGNDistance + extern const TagDetails nikonFlashGNDistance[] = { + { 0, N_("None") }, + { 1, N_("0.1 m") }, + { 2, N_("0.2 m") }, + { 3, N_("0.3 m") }, + { 4, N_("0.4 m") }, + { 5, N_("0.5 m") }, + { 6, N_("0.6 m") }, + { 7, N_("0.7 m") }, + { 8, N_("0.8 m") }, + { 9, N_("0.9 m") }, + { 10, N_("1.0 m") }, + { 11, N_("1.1 m") }, + { 12, N_("1.3 m") }, + { 13, N_("1.4 m") }, + { 14, N_("1.6 m") }, + { 15, N_("1.8 m") }, + { 16, N_("2.0 m") }, + { 17, N_("2.2 m") }, + { 18, N_("2.5 m") }, + { 19, N_("2.8 m") }, + { 20, N_("3.2 m") }, + { 21, N_("3.6 m") }, + { 22, N_("4.0 m") }, + { 23, N_("4.5 m") }, + { 24, N_("5.0 m") }, + { 25, N_("5.6 m") }, + { 26, N_("6.3 m") }, + { 27, N_("7.1 m") }, + { 28, N_("8.0 m") }, + { 29, N_("9.0 m") }, + { 30, N_("10.0 m") }, + { 31, N_("11.0 m") }, + { 32, N_("13.0 m") }, + { 33, N_("14.0 m") }, + { 34, N_("16.0 m") }, + { 35, N_("18.0 m") }, + { 36, N_("20.0 m") }, + { 255, N_("n/a") } + }; + + //! FlashControlMode + extern const TagDetails nikonFlashControlMode[] = { + { 0, N_("Off") }, + { 1, N_("iTTL-BL") }, + { 2, N_("iTTL") }, + { 3, N_("Auto Aperture") }, + { 4, N_("Automatic") }, + { 5, N_("GN (distance priority)") }, + { 6, N_("Manual") }, + { 7, N_("Repeating Flash") } + }; + + //! ExternalFlashFlags + extern const TagDetails nikonExternalFlashFlags[] = { + { 0, N_("Fired") }, + { 2, N_("Bounce Flash") }, + { 4, N_("Wide Flash Adapter") } + }; + + //! FlashColorFilter + extern const TagDetails nikonFlashColorFilter[] = { + { 0, N_("None") }, + { 1, N_("FL-GL1") }, + { 2, N_("FL-GL2") }, + { 9, N_("TN-A1") }, + { 10, N_("TN-A2") }, + { 65, N_("Red") }, + { 66, N_("Blue") }, + { 67, N_("Yellow") }, + { 68, N_("Amber") } + }; + + // Nikon3 Flash Info 1 Tag Info + const TagInfo Nikon3MakerNote::tagInfoFl1_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonFl1IfdId, makerTags, undefined, printExifVersion), + TagInfo( 4, "FlashSource", N_("Flash Source"), N_("Flash source"), nikonFl1IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashSource)), + TagInfo( 5, "0x0005", N_("0x0005"), N_("Unknown"), nikonFl1IfdId, makerTags, unsignedByte, printValue), + TagInfo( 6, "ExternalFlashFirmware", N_("External Flash Firmware"), N_("External flash firmware"), nikonFl1IfdId, makerTags, unsignedByte, printValue), + TagInfo( 8, "ExternalFlashFlags", N_("External Flash Flags"), N_("External flash flags"), nikonFl1IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonExternalFlashFlags)), + TagInfo( 11, "FlashFocalLength", N_("Flash Focal Length"), N_("Flash focal length"), nikonFl1IfdId, makerTags, unsignedByte, printFlashFocalLength), + TagInfo( 12, "RepeatingFlashRate", N_("Repeating Flash Rate"), N_("Repeating flash rate"), nikonFl1IfdId, makerTags, unsignedByte, printRepeatingFlashRate), + TagInfo( 13, "RepeatingFlashCount", N_("Repeating Flash Count"), N_("Repeating flash count"), nikonFl1IfdId, makerTags, unsignedByte, printRepeatingFlashCount), + TagInfo( 14, "FlashGNDistance", N_("Flash GN Distance"), N_("Flash GN distance"), nikonFl1IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashGNDistance)), + TagInfo( 15, "FlashGroupAControlMode", N_("Flash Group A Control Mode"), N_("Flash group a control mode"), nikonFl1IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashControlMode)), + TagInfo( 16, "FlashGroupBControlMode", N_("Flash Group B Control Mode"), N_("Flash group b control mode"), nikonFl1IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashControlMode)), + // End of list marker + TagInfo(0xffff, "(UnknownNikonMeTag)", "(UnknownNikonMeTag)", N_("Unknown Nikon Multi Exposure Tag"), nikonFl1IfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListFl1() + { + return tagInfoFl1_; + } + + // Nikon3 Flash Info 2 Tag Info + const TagInfo Nikon3MakerNote::tagInfoFl2_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonFl2IfdId, makerTags, undefined, printExifVersion), + TagInfo( 4, "FlashSource", N_("Flash Source"), N_("Flash source"), nikonFl2IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashSource)), + TagInfo( 5, "0x0005", N_("0x0005"), N_("Unknown"), nikonFl2IfdId, makerTags, unsignedByte, printValue), + TagInfo( 6, "ExternalFlashFirmware", N_("External Flash Firmware"), N_("External flash firmware"), nikonFl2IfdId, makerTags, unsignedByte, printValue), + TagInfo( 8, "ExternalFlashFlags", N_("External Flash Flags"), N_("External flash flags"), nikonFl2IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonExternalFlashFlags)), + TagInfo( 12, "FlashFocalLength", N_("Flash Focal Length"), N_("Flash focal length"), nikonFl2IfdId, makerTags, unsignedByte, printFlashFocalLength), + TagInfo( 13, "RepeatingFlashRate", N_("Repeating Flash Rate"), N_("Repeating flash rate"), nikonFl2IfdId, makerTags, unsignedByte, printRepeatingFlashRate), + TagInfo( 14, "RepeatingFlashCount", N_("Repeating Flash Count"), N_("Repeating flash count"), nikonFl2IfdId, makerTags, unsignedByte, printRepeatingFlashCount), + TagInfo( 15, "FlashGNDistance", N_("Flash GN Distance"), N_("Flash GN distance"), nikonFl2IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashGNDistance)), + // End of list marker + TagInfo(0xffff, "(UnknownNikonMeTag)", "(UnknownNikonMeTag)", N_("Unknown Nikon Multi Exposure Tag"), nikonFl2IfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListFl2() + { + return tagInfoFl2_; + } + + // Nikon3 Flash Info 3 Tag Info + const TagInfo Nikon3MakerNote::tagInfoFl3_[] = { + TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonFl3IfdId, makerTags, undefined, printExifVersion), + TagInfo( 4, "FlashSource", N_("Flash Source"), N_("Flash source"), nikonFl3IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashSource)), + TagInfo( 6, "ExternalFlashFirmware", N_("External Flash Firmware"), N_("External flash firmware"), nikonFl3IfdId, makerTags, unsignedByte, printValue), + TagInfo( 8, "ExternalFlashFlags", N_("External Flash Flags"), N_("External flash flags"), nikonFl3IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonExternalFlashFlags)), + TagInfo( 12, "FlashFocalLength", N_("Flash Focal Length"), N_("Flash focal length"), nikonFl3IfdId, makerTags, unsignedByte, printFlashFocalLength), + TagInfo( 13, "RepeatingFlashRate", N_("Repeating Flash Rate"), N_("Repeating flash rate"), nikonFl3IfdId, makerTags, unsignedByte, printRepeatingFlashRate), + TagInfo( 14, "RepeatingFlashCount", N_("Repeating Flash Count"), N_("Repeating flash count"), nikonFl3IfdId, makerTags, unsignedByte, printRepeatingFlashCount), + TagInfo( 15, "FlashGNDistance", N_("Flash GN Distance"), N_("Flash GN distance"), nikonFl3IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashGNDistance)), + TagInfo( 16, "FlashColorFilter", N_("Flash Color Filter"), N_("Flash color filter"), nikonFl3IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashColorFilter)), + // End of list marker + TagInfo(0xffff, "(UnknownNikonMeTag)", "(UnknownNikonMeTag)", N_("Unknown Nikon Multi Exposure Tag"), nikonFl3IfdId, makerTags, invalidTypeId, printValue) + }; + + const TagInfo* Nikon3MakerNote::tagListFl3() + { + return tagInfoFl3_; + } + // Nikon3 Shot Info D80 Tag Info const TagInfo Nikon3MakerNote::tagInfoSi1_[] = { TagInfo( 0, "Version", N_("Version"), N_("Version"), nikonSi1IfdId, makerTags, unsignedByte, printExifVersion), @@ -2063,8 +2274,8 @@ fmountlens[] = { #endif // EXV_HAVE_LENSDATA } - std::ostream& Nikon3MakerNote::printFocusDistance(std::ostream& os, - const Value& value, + std::ostream& Nikon3MakerNote::printFocusDistance(std::ostream& os, + const Value& value, const ExifData*) { if (value.count() != 1 || value.typeId() != unsignedByte) { @@ -2138,6 +2349,48 @@ fmountlens[] = { return os; } + std::ostream& Nikon3MakerNote::printFlashFocalLength(std::ostream& os, + const Value& value, + const ExifData*) + { + if (value.count() != 1 || value.typeId() != unsignedByte || value.toLong() == 0 || value.toLong() == 255) { + return os << "(" << value << ")"; + } + std::ostringstream oss; + oss.copyfmt(os); + os << std::fixed << std::setprecision(2) << value.toLong() << " mm"; + os.copyfmt(oss); + return os; + } + + std::ostream& Nikon3MakerNote::printRepeatingFlashRate(std::ostream& os, + const Value& value, + const ExifData*) + { + if (value.count() != 1 || value.typeId() != unsignedByte || value.toLong() == 0 || value.toLong() == 255) { + return os << "(" << value << ")"; + } + std::ostringstream oss; + oss.copyfmt(os); + os << std::fixed << std::setprecision(2) << value.toLong() << " Hz"; + os.copyfmt(oss); + return os; + } + + std::ostream& Nikon3MakerNote::printRepeatingFlashCount(std::ostream& os, + const Value& value, + const ExifData*) + { + if (value.count() != 1 || value.typeId() != unsignedByte || value.toLong() == 0 || value.toLong() == 255) { + return os << "(" << value << ")"; + } + std::ostringstream oss; + oss.copyfmt(os); + os << std::fixed << std::setprecision(2) << value.toLong(); + os.copyfmt(oss); + return os; + } + std::ostream& Nikon3MakerNote::print0x009a(std::ostream& os, const Value& value, const ExifData*) diff --git a/src/nikonmn.hpp b/src/nikonmn.hpp index 50738714..8b1e8719 100644 --- a/src/nikonmn.hpp +++ b/src/nikonmn.hpp @@ -120,6 +120,18 @@ namespace Exiv2 { static const TagInfo* tagListIi(); //! Return read-only list of built-in Auto Focus tags static const TagInfo* tagListAf(); + //! Return read-only list of built-in Auto Focus 2 tags + static const TagInfo* tagListAf2(); + //! Return read-only list of built-in File Info tags + static const TagInfo* tagListFi(); + //! Return read-only list of built-in Multi Exposure tags + static const TagInfo* tagListMe(); + //! Return read-only list of built-in Flash Info 1 tags + static const TagInfo* tagListFl1(); + //! Return read-only list of built-in Flash Info 2 tags + static const TagInfo* tagListFl2(); + //! Return read-only list of built-in Flash Info 3 tags + static const TagInfo* tagListFl3(); //! Return read-only list of built-in Shot Info D80 tags static const TagInfo* tagListSi1(); //! Return read-only list of built-in Shot Info D40 tags @@ -192,6 +204,12 @@ namespace Exiv2 { static std::ostream& print0x009e(std::ostream& os, const Value& value, const ExifData*); //! Print Exif.NikonIi.ISO(2) static std::ostream& printIiIso(std::ostream& os, const Value& value, const ExifData*); + //! Print flash focal length + static std::ostream& printFlashFocalLength(std::ostream& os, const Value& value, const ExifData*); + //! Print repeating flash rate + static std::ostream& printRepeatingFlashRate(std::ostream& os, const Value& value, const ExifData*); + //! Print repeating flash count + static std::ostream& printRepeatingFlashCount(std::ostream& os, const Value& value, const ExifData*); //@} private: @@ -207,6 +225,18 @@ namespace Exiv2 { static const TagInfo tagInfoIi_[]; //! Auto Focus tag information static const TagInfo tagInfoAf_[]; + //! Auto Focus tag 2 information + static const TagInfo tagInfoAf2_[]; + //! File Info tag information + static const TagInfo tagInfoFi_[]; + //! Multi Exposure tag information + static const TagInfo tagInfoMe_[]; + //! Flash Info 1 tag information + static const TagInfo tagInfoFl1_[]; + //! Flash Info 2 tag information + static const TagInfo tagInfoFl2_[]; + //! Flash Info 3 tag information + static const TagInfo tagInfoFl3_[]; //! Shot Info D80 tag information static const TagInfo tagInfoSi1_[]; //! Shot Info D40 tag information diff --git a/src/tags.cpp b/src/tags.cpp index 54996531..0f41097c 100644 --- a/src/tags.cpp +++ b/src/tags.cpp @@ -143,6 +143,12 @@ namespace Exiv2 { { nikonWtIfdId, "Makernote", "NikonWt", Nikon3MakerNote::tagListWt }, { nikonIiIfdId, "Makernote", "NikonIi", Nikon3MakerNote::tagListIi }, { nikonAfIfdId, "Makernote", "NikonAf", Nikon3MakerNote::tagListAf }, + { nikonAf2IfdId, "Makernote", "NikonAf2", Nikon3MakerNote::tagListAf2 }, + { nikonFiIfdId, "Makernote", "NikonFi", Nikon3MakerNote::tagListFi }, + { nikonMeIfdId, "Makernote", "NikonMe", Nikon3MakerNote::tagListMe }, + { nikonFl1IfdId, "Makernote", "NikonFl1", Nikon3MakerNote::tagListFl1 }, + { nikonFl2IfdId, "Makernote", "NikonFl2", Nikon3MakerNote::tagListFl2 }, + { nikonFl3IfdId, "Makernote", "NikonFl3", Nikon3MakerNote::tagListFl3 }, { nikonSi1IfdId, "Makernote", "NikonSiD80", Nikon3MakerNote::tagListSi1 }, { nikonSi2IfdId, "Makernote", "NikonSiD40", Nikon3MakerNote::tagListSi2 }, { nikonSi3IfdId, "Makernote", "NikonSiD300a", Nikon3MakerNote::tagListSi3 }, diff --git a/src/tiffcomposite.cpp b/src/tiffcomposite.cpp index 32e686c1..06195267 100644 --- a/src/tiffcomposite.cpp +++ b/src/tiffcomposite.cpp @@ -200,6 +200,12 @@ namespace Exiv2 { { 359, "SonySR2Data19"}, { 360, "SonyIDC" }, { 361, "SonyIDC2" }, + { 362, "NikonFi" }, + { 363, "NikonAf2" }, + { 364, "NikonMe" }, + { 365, "NikonFl1" }, + { 366, "NikonFl2" }, + { 367, "NikonFl3" }, }; bool TiffGroupInfo::operator==(const uint16_t& group) const diff --git a/src/tiffimage.cpp b/src/tiffimage.cpp index 16a60b53..784c163c 100644 --- a/src/tiffimage.cpp +++ b/src/tiffimage.cpp @@ -477,6 +477,145 @@ namespace Exiv2 { { 2, ttUnsignedShort, 1 } // The array contains 4 bytes }; + //! Nikon Auto Focus 2 binary array - configuration + extern const ArrayCfg nikonAf2Cfg = { + Group::nikonaf2, // Group for the elements + littleEndian, // 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 2 binary array - definition + extern const ArrayDef nikonAf2Def[] = { + { 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 File Info binary array - configuration + extern const ArrayCfg nikonFiCfg = { + Group::nikonfi, // Group for the elements + littleEndian, // 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 File Info binary array - definition + extern const ArrayDef nikonFiDef[] = { + { 0, ttUndefined, 4 }, // Version + { 6, ttUnsignedShort, 1 }, // Directory Number + { 8, ttUnsignedShort, 1 } // File Number + }; + + //! Nikon File Info binary array - configuration + extern const ArrayCfg nikonMeCfg = { + Group::nikonme, // Group for the elements + littleEndian, // 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 File Info 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 = { + Group::nikonfl1, // Group for the elements + littleEndian, // Byte order + ttUndefined, // Type for array entry + notEncrypted, // Not encrypted + false, // No size element + true, // Write all tags + true, // Concatenate gaps + { 0, ttUnsignedByte, 1 } + }; + extern const ArrayDef nikonFl1Def[] = { + { 0, ttUndefined, 4 }, // Version + { 4, ttUnsignedByte, 1 }, // FlashSource + { 6, ttUnsignedByte, 2 }, // 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 = { + Group::nikonfl2, // Group for the elements + littleEndian, // Byte order + ttUndefined, // Type for array entry + notEncrypted, // Not encrypted + false, // No size element + true, // Write all tags + true, // Concatenate gaps + { 0, ttUnsignedByte, 1 } + }; + extern const ArrayDef nikonFl2Def[] = { + { 0, ttUndefined, 4 }, // Version + { 4, ttUnsignedByte, 1 }, // FlashSource + { 6, ttUnsignedByte, 2 }, // 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 = { + Group::nikonfl3, // Group for the elements + littleEndian, // 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 Flash Info binary array - definition + extern const ArrayDef nikonFl3Def[] = { + { 0, ttUndefined, 4 }, // Version + { 4, ttUnsignedByte, 1 }, // FlashSource + { 6, ttUnsignedByte, 2 }, // 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 = { Group::nikonsi1, // Group for the elements @@ -1038,6 +1177,12 @@ namespace Exiv2 { { Tag::root, Group::nikonld1, Group::nikon3mn, 0x0098 }, { Tag::root, Group::nikonld2, Group::nikon3mn, 0x0098 }, { Tag::root, Group::nikonld3, Group::nikon3mn, 0x0098 }, + { Tag::root, Group::nikonme, Group::nikon3mn, 0x00b0 }, + { Tag::root, Group::nikonaf2, Group::nikon3mn, 0x00b7 }, + { Tag::root, Group::nikonfi, Group::nikon3mn, 0x00b8 }, + { Tag::root, Group::nikonfl1, Group::nikon3mn, 0x00a8 }, + { Tag::root, Group::nikonfl2, Group::nikon3mn, 0x00a8 }, + { Tag::root, Group::nikonfl3, Group::nikon3mn, 0x00a8 }, { Tag::root, Group::panamn, Group::exif, 0x927c }, { Tag::root, Group::pentaxmn, Group::exif, 0x927c }, { Tag::root, Group::sigmamn, Group::exif, 0x927c }, @@ -1450,6 +1595,10 @@ namespace Exiv2 { { 0x0091, Group::nikon3mn, EXV_COMPLEX_BINARY_ARRAY(nikonSiSet, nikonSelector) }, { 0x0097, Group::nikon3mn, EXV_COMPLEX_BINARY_ARRAY(nikonCbSet, nikonSelector) }, { 0x0098, Group::nikon3mn, EXV_COMPLEX_BINARY_ARRAY(nikonLdSet, nikonSelector) }, + { 0x00a8, Group::nikon3mn, EXV_COMPLEX_BINARY_ARRAY(nikonFlSet, nikonSelector) }, + { 0x00b0, Group::nikon3mn, EXV_BINARY_ARRAY(nikonMeCfg, nikonMeDef) }, + { 0x00b7, Group::nikon3mn, EXV_BINARY_ARRAY(nikonAf2Cfg, nikonAf2Def) }, + { 0x00b8, Group::nikon3mn, EXV_BINARY_ARRAY(nikonFiCfg, nikonFiDef) }, { Tag::all, Group::nikon3mn, newTiffEntry }, // Nikon3 makernote preview subdir @@ -1472,6 +1621,20 @@ namespace Exiv2 { // Nikon3 auto focus { Tag::all, Group::nikonaf, newTiffBinaryElement }, + + // Nikon3 auto focus 2 + { Tag::all, Group::nikonaf2, newTiffBinaryElement }, + + // Nikon3 file info + { Tag::all, Group::nikonfi, newTiffBinaryElement }, + + // Nikon3 file info + { Tag::all, Group::nikonme, newTiffBinaryElement }, + + // Nikon3 flash info + { Tag::all, Group::nikonfl1, newTiffBinaryElement }, + { Tag::all, Group::nikonfl2, newTiffBinaryElement }, + { Tag::all, Group::nikonfl3, newTiffBinaryElement }, // Nikon3 shot info { Tag::all, Group::nikonsi1, newTiffBinaryElement }, diff --git a/src/types.hpp b/src/types.hpp index 44f550fe..21ba684e 100644 --- a/src/types.hpp +++ b/src/types.hpp @@ -196,6 +196,12 @@ namespace Exiv2 { nikonWtIfdId, nikonIiIfdId, nikonAfIfdId, + nikonAf2IfdId, + nikonFiIfdId, + nikonMeIfdId, + nikonFl1IfdId, + nikonFl2IfdId, + nikonFl3IfdId, nikonSi1IfdId, nikonSi2IfdId, nikonSi3IfdId,