xymp
/
exiv2
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove using

Browse Source 
Signed-off-by: Rosen Penev <rosenp@gmail.com>
main
Rosen Penev 3 years ago
parent 235b1e0d19
commit 2fa84f4bab
6 changed files with 74 additions and 83 deletions
Show Stats Download Patch File Download Diff File

10
app/exiv2.cpp
Unescape Escape View File

@ -42,11 +42,11 @@ constexpr auto emptyYodAdjust_ = std::array{
//! List of all command identifiers and corresponding strings
constexpr auto cmdIdAndString = std::array{
CmdIdAndString{CmdId::add, "add"},
CmdIdAndString{CmdId::set, "set"},
CmdIdAndString{CmdId::del, "del"},
CmdIdAndString{CmdId::reg, "reg"},
CmdIdAndString{CmdId::invalid, "invalidCmd"}, // End of list marker
std::pair(CmdId::add, "add"),
std::pair(CmdId::set, "set"),
std::pair(CmdId::del, "del"),
std::pair(CmdId::reg, "reg"),
std::pair(CmdId::invalid, "invalidCmd"), // End of list marker
};
// Return a command Id for a command string

2
app/exiv2app.hpp
Unescape Escape View File

@ -62,8 +62,6 @@ struct ModifyCmd {
};
//! Container for modification commands
using ModifyCmds = std::vector<ModifyCmd>;
//! Structure to link command identifiers to strings
using CmdIdAndString = std::pair<CmdId, std::string_view>;
/*!
@brief Implements the command line handling for the program.

73
samples/easyaccess-test.cpp
Unescape Escape View File

@ -5,44 +5,41 @@
#include <iomanip>
#include <iostream>
using EasyAccessFct = Exiv2::ExifData::const_iterator (*)(const Exiv2::ExifData&);
using EasyAccess = std::pair<const char*, EasyAccessFct>;
static const EasyAccess easyAccess[] = {
{"Orientation", Exiv2::orientation},
{"ISO speed", Exiv2::isoSpeed},
{"Date & time original", Exiv2::dateTimeOriginal},
{"Flash bias", Exiv2::flashBias},
{"Exposure mode", Exiv2::exposureMode},
{"Scene mode", Exiv2::sceneMode},
{"Macro mode", Exiv2::macroMode},
{"Image quality", Exiv2::imageQuality},
{"White balance", Exiv2::whiteBalance},
{"Lens name", Exiv2::lensName},
{"Saturation", Exiv2::saturation},
{"Sharpness", Exiv2::sharpness},
{"Contrast", Exiv2::contrast},
{"Scene capture type", Exiv2::sceneCaptureType},
{"Metering mode", Exiv2::meteringMode},
{"Camera make", Exiv2::make},
{"Camera model", Exiv2::model},
{"Exposure time", Exiv2::exposureTime},
{"FNumber", Exiv2::fNumber},
{"Shutter speed value", Exiv2::shutterSpeedValue},
{"Aperture value", Exiv2::apertureValue},
{"Brightness value", Exiv2::brightnessValue},
{"Exposure bias", Exiv2::exposureBiasValue},
{"Max aperture value", Exiv2::maxApertureValue},
{"Subject distance", Exiv2::subjectDistance},
{"Light source", Exiv2::lightSource},
{"Flash", Exiv2::flash},
{"Camera serial number", Exiv2::serialNumber},
{"Focal length", Exiv2::focalLength},
{"Subject location/area", Exiv2::subjectArea},
{"Flash energy", Exiv2::flashEnergy},
{"Exposure index", Exiv2::exposureIndex},
{"Sensing method", Exiv2::sensingMethod},
{"AF point", Exiv2::afPoint},
static constexpr auto easyAccess = std::array{
std::pair("Orientation", &Exiv2::orientation),
std::pair("ISO speed", &Exiv2::isoSpeed),
std::pair("Date & time original", &Exiv2::dateTimeOriginal),
std::pair("Flash bias", &Exiv2::flashBias),
std::pair("Exposure mode", &Exiv2::exposureMode),
std::pair("Scene mode", &Exiv2::sceneMode),
std::pair("Macro mode", &Exiv2::macroMode),
std::pair("Image quality", &Exiv2::imageQuality),
std::pair("White balance", &Exiv2::whiteBalance),
std::pair("Lens name", &Exiv2::lensName),
std::pair("Saturation", &Exiv2::saturation),
std::pair("Sharpness", &Exiv2::sharpness),
std::pair("Contrast", &Exiv2::contrast),
std::pair("Scene capture type", &Exiv2::sceneCaptureType),
std::pair("Metering mode", &Exiv2::meteringMode),
std::pair("Camera make", &Exiv2::make),
std::pair("Camera model", &Exiv2::model),
std::pair("Exposure time", &Exiv2::exposureTime),
std::pair("FNumber", &Exiv2::fNumber),
std::pair("Shutter speed value", &Exiv2::shutterSpeedValue),
std::pair("Aperture value", &Exiv2::apertureValue),
std::pair("Brightness value", &Exiv2::brightnessValue),
std::pair("Exposure bias", &Exiv2::exposureBiasValue),
std::pair("Max aperture value", &Exiv2::maxApertureValue),
std::pair("Subject distance", &Exiv2::subjectDistance),
std::pair("Light source", &Exiv2::lightSource),
std::pair("Flash", &Exiv2::flash),
std::pair("Camera serial number", &Exiv2::serialNumber),
std::pair("Focal length", &Exiv2::focalLength),
std::pair("Subject location/area", &Exiv2::subjectArea),
std::pair("Flash energy", &Exiv2::flashEnergy),
std::pair("Exposure index", &Exiv2::exposureIndex),
std::pair("Sensing method", &Exiv2::sensingMethod),
std::pair("AF point", &Exiv2::afPoint),
};
int main(int argc, char** argv) {

57
src/exif.cpp
Unescape Escape View File

@ -501,7 +501,6 @@ ByteOrder ExifParser::decode(ExifData& exifData, const byte* pData, size_t size)
//! @cond IGNORE
enum Ptt { pttLen, pttTag, pttIfd };
using PreviewTags = std::pair<Ptt, const char*>;
//! @endcond
WriteMethod ExifParser::encode(Blob& blob, const byte* pData, size_t size, ByteOrder byteOrder,
@ -579,34 +578,34 @@ WriteMethod ExifParser::encode(Blob& blob, const byte* pData, size_t size, ByteO
// Todo: Enhance preview classes to be able to write and delete previews and use that instead.
// Table must be sorted by preview, the first tag in each group is the size
static constexpr auto filteredPvTags = std::array{
PreviewTags(pttLen, "Exif.Minolta.ThumbnailLength"),
PreviewTags(pttTag, "Exif.Minolta.ThumbnailOffset"),
PreviewTags(pttLen, "Exif.Minolta.Thumbnail"),
PreviewTags(pttLen, "Exif.NikonPreview.JPEGInterchangeFormatLength"),
PreviewTags(pttIfd, "NikonPreview"),
PreviewTags(pttLen, "Exif.Olympus.ThumbnailLength"),
PreviewTags(pttTag, "Exif.Olympus.ThumbnailOffset"),
PreviewTags(pttLen, "Exif.Olympus.ThumbnailImage"),
PreviewTags(pttLen, "Exif.Olympus.Thumbnail"),
PreviewTags(pttLen, "Exif.Olympus2.ThumbnailLength"),
PreviewTags(pttTag, "Exif.Olympus2.ThumbnailOffset"),
PreviewTags(pttLen, "Exif.Olympus2.ThumbnailImage"),
PreviewTags(pttLen, "Exif.Olympus2.Thumbnail"),
PreviewTags(pttLen, "Exif.OlympusCs.PreviewImageLength"),
PreviewTags(pttTag, "Exif.OlympusCs.PreviewImageStart"),
PreviewTags(pttTag, "Exif.OlympusCs.PreviewImageValid"),
PreviewTags(pttLen, "Exif.Pentax.PreviewLength"),
PreviewTags(pttTag, "Exif.Pentax.PreviewOffset"),
PreviewTags(pttTag, "Exif.Pentax.PreviewResolution"),
PreviewTags(pttLen, "Exif.PentaxDng.PreviewLength"),
PreviewTags(pttTag, "Exif.PentaxDng.PreviewOffset"),
PreviewTags(pttTag, "Exif.PentaxDng.PreviewResolution"),
PreviewTags(pttLen, "Exif.SamsungPreview.JPEGInterchangeFormatLength"),
PreviewTags(pttIfd, "SamsungPreview"),
PreviewTags(pttLen, "Exif.Thumbnail.StripByteCounts"),
PreviewTags(pttIfd, "Thumbnail"),
PreviewTags(pttLen, "Exif.Thumbnail.JPEGInterchangeFormatLength"),
PreviewTags(pttIfd, "Thumbnail"),
std::pair(pttLen, "Exif.Minolta.ThumbnailLength"),
std::pair(pttTag, "Exif.Minolta.ThumbnailOffset"),
std::pair(pttLen, "Exif.Minolta.Thumbnail"),
std::pair(pttLen, "Exif.NikonPreview.JPEGInterchangeFormatLength"),
std::pair(pttIfd, "NikonPreview"),
std::pair(pttLen, "Exif.Olympus.ThumbnailLength"),
std::pair(pttTag, "Exif.Olympus.ThumbnailOffset"),
std::pair(pttLen, "Exif.Olympus.ThumbnailImage"),
std::pair(pttLen, "Exif.Olympus.Thumbnail"),
std::pair(pttLen, "Exif.Olympus2.ThumbnailLength"),
std::pair(pttTag, "Exif.Olympus2.ThumbnailOffset"),
std::pair(pttLen, "Exif.Olympus2.ThumbnailImage"),
std::pair(pttLen, "Exif.Olympus2.Thumbnail"),
std::pair(pttLen, "Exif.OlympusCs.PreviewImageLength"),
std::pair(pttTag, "Exif.OlympusCs.PreviewImageStart"),
std::pair(pttTag, "Exif.OlympusCs.PreviewImageValid"),
std::pair(pttLen, "Exif.Pentax.PreviewLength"),
std::pair(pttTag, "Exif.Pentax.PreviewOffset"),
std::pair(pttTag, "Exif.Pentax.PreviewResolution"),
std::pair(pttLen, "Exif.PentaxDng.PreviewLength"),
std::pair(pttTag, "Exif.PentaxDng.PreviewOffset"),
std::pair(pttTag, "Exif.PentaxDng.PreviewResolution"),
std::pair(pttLen, "Exif.SamsungPreview.JPEGInterchangeFormatLength"),
std::pair(pttIfd, "SamsungPreview"),
std::pair(pttLen, "Exif.Thumbnail.StripByteCounts"),
std::pair(pttIfd, "Thumbnail"),
std::pair(pttLen, "Exif.Thumbnail.JPEGInterchangeFormatLength"),
std::pair(pttIfd, "Thumbnail"),
};
bool delTags = false;
for (auto&& [ptt, key] : filteredPvTags) {

7
src/minoltamn_int.cpp
Unescape Escape View File

@ -1641,12 +1641,11 @@ static std::ostream& resolveLens0xffff(std::ostream& os, const Value& value, con
return EXV_PRINT_TAG(minoltaSonyLensID)(os, value, metadata);
}
using LensIdFct = std::pair<uint32_t, PrintFct>;
//! List of lens ids which require special treatment from printMinoltaSonyLensID
constexpr auto lensIdFct = std::array{
LensIdFct(0x001c, resolveLens0x1c), LensIdFct(0x0029, resolveLens0x29), LensIdFct(0x0034, resolveLens0x34),
LensIdFct(0x0080, resolveLens0x80), LensIdFct(0x00ff, resolveLens0xff), LensIdFct(0xffff, resolveLens0xffff),
// { 0x00ff, resolveLensTypeUsingExiftool }, // was used for debugging
std::pair(0x001cu, &resolveLens0x1c), std::pair(0x0029u, &resolveLens0x29), std::pair(0x0034u, &resolveLens0x34),
std::pair(0x0080u, &resolveLens0x80), std::pair(0x00ffu, &resolveLens0xff), std::pair(0xffffu, &resolveLens0xffff),
// std::pair(0x00ff, resolveLensTypeUsingExiftool), // was used for debugging
};
// #1145 end - respect lenses with shared LensID
// ----------------------------------------------------------------------

8
src/tiffimage.cpp
Unescape Escape View File

@ -42,13 +42,11 @@ TiffImage::TiffImage(BasicIo::UniquePtr io, bool /*create*/) :
Image(ImageType::tiff, mdExif | mdIptc | mdXmp, std::move(io)) {
} // TiffImage::TiffImage
//! Structure for TIFF compression to MIME type mappings
using MimeTypeList = std::pair<int, const char*>;
//! List of TIFF compression to MIME type mappings
constexpr auto mimeTypeList = std::array{
MimeTypeList(32770, "image/x-samsung-srw"),
MimeTypeList(34713, "image/x-nikon-nef"),
MimeTypeList(65535, "image/x-pentax-pef"),
std::pair(32770, "image/x-samsung-srw"),
std::pair(34713, "image/x-nikon-nef"),
std::pair(65535, "image/x-pentax-pef"),
};
std::string TiffImage::mimeType() const {

Write Preview
Loading…
Cancel
Save